diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 00000000..4c12eee4
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,364 @@
+name: Run Tests
+
+on:
+ push:
+ branches:
+ - develop
+ pull_request:
+ branches:
+ - develop
+
+jobs:
+ test:
+ name: Test ${{ matrix.service }}
+ runs-on: ubuntu-latest
+ strategy:
+ fail-fast: false
+ max-parallel: 1
+ matrix:
+ service:
+ - objects
+ - network_services
+ - security_services
+ - identity_services
+ - deployment_services
+ - config_setup
+ - config_operations
+ - device_settings
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.11'
+ cache: 'pip'
+
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install -e .
+ pip install pytest pytest-cov pytest-json-report
+
+ - name: Create SCM config file from secrets
+ run: |
+ mkdir -p config
+ cat > config/scm-config.json << 'EOF'
+ {
+ "auth_url": "${{ secrets.SCM_AUTH_URL }}",
+ "client_id": "${{ secrets.SCM_CLIENT_ID }}",
+ "client_secret": "${{ secrets.SCM_CLIENT_SECRET }}",
+ "host": "${{ secrets.SCM_HOST }}",
+ "protocol": "${{ secrets.SCM_PROTOCOL }}",
+ "scope": "${{ secrets.SCM_SCOPE }}",
+ "logging": "quiet",
+ "skip_verify_certificate": ${{ secrets.SCM_SKIP_VERIFY_CERTIFICATE }}
+ }
+ EOF
+
+ - name: Run tests for ${{ matrix.service }}
+ env:
+ SCM_CLIENT_ID: ${{ secrets.SCM_CLIENT_ID }}
+ SCM_CLIENT_SECRET: ${{ secrets.SCM_CLIENT_SECRET }}
+ SCM_SCOPE: ${{ secrets.SCM_SCOPE }}
+ SCM_TSG_ID: ${{ secrets.SCM_TSG_ID }}
+ SCM_HOST: ${{ secrets.SCM_HOST }}
+ SCM_AUTH_URL: ${{ secrets.SCM_AUTH_URL }}
+ PYTHONWARNINGS: ignore
+ SCM_LOGGING: quiet
+ run: |
+ set +e
+
+ pytest -v -rs --json-report --json-report-file=test-report.json scm/${{ matrix.service }}/tests/
+ exit_code=$?
+
+ # Parse JSON report and create detailed markdown summary
+ cat > parse_pytest.py << 'PYTHON'
+ import json
+ import sys
+ import os
+
+ try:
+ with open('test-report.json', 'r') as f:
+ report = json.load(f)
+ except FileNotFoundError:
+ print("No test report found")
+ # Write empty stats
+ stats = {
+ "package": "${{ matrix.service }}",
+ "passed": 0,
+ "failed": 0,
+ "skipped": 0,
+ "errored": 0,
+ "total": 0
+ }
+ with open('test-stats-${{ matrix.service }}.json', 'w') as f:
+ json.dump(stats, f, indent=2)
+ sys.exit(0)
+
+ tests = report.get('tests', [])
+
+ passed = [t for t in tests if t.get('outcome') == 'passed']
+ failed = [t for t in tests if t.get('outcome') == 'failed']
+ skipped = [t for t in tests if t.get('outcome') == 'skipped']
+ errored = [t for t in tests if t.get('outcome') == 'error']
+
+ # Print summary to console
+ print(f"\n{'='*60}")
+ print(f"Test Results: ${{ matrix.service }}")
+ print(f"{'='*60}")
+ print(f"Passed: {len(passed)}")
+ print(f"Failed: {len(failed)}")
+ print(f"Errors: {len(errored)}")
+ print(f"Skipped: {len(skipped)}")
+ print(f"{'='*60}\n")
+
+ # Write detailed markdown to file
+ with open('test-detail-${{ matrix.service }}.md', 'w') as f:
+ f.write(f'\n\n')
+ f.write(f"## ${{ matrix.service }}\n\n")
+ f.write(f"**{len(passed)} passed, {len(failed)} failed, {len(errored)} errors, {len(skipped)} skipped**\n\n")
+
+ if failed or errored:
+ f.write("### Failed Tests\n\n")
+ for test in failed + errored:
+ test_name = test.get('nodeid', 'Unknown')
+ duration = test.get('duration', 0)
+ outcome = test.get('outcome', 'failed')
+ f.write(f"#### `{test_name}` ({duration:.2f}s) [{outcome}]\n\n")
+
+ # Extract error information from call or setup phase
+ call = test.get('call', {})
+ setup = test.get('setup', {})
+ longrepr = call.get('longrepr', '') or setup.get('longrepr', '')
+
+ # Also capture stdout which contains our header logging
+ stdout = call.get('stdout', '') or setup.get('stdout', '')
+
+ if longrepr or stdout:
+ f.write("\nError Details
\n\n")
+ f.write("```\n")
+
+ # Include stdout first (contains X-Request-ID, X-Trace-ID, etc.)
+ if stdout:
+ stdout_lines = stdout.strip().split('\n')
+ # Look for our header block in stdout
+ for line in stdout_lines:
+ if any(keyword in line for keyword in ['API RESPONSE HEADERS', 'API ERROR RESPONSE', 'X-Request-ID:', 'X-Trace-ID:', 'Status Code:', 'Error Body:']):
+ f.write(line + '\n')
+
+ # Include traceback
+ if longrepr:
+ lines = longrepr.split('\n')
+ f.write('\n'.join(lines[-20:]))
+
+ f.write("\n```\n")
+ f.write(" \n\n")
+ else:
+ f.write("_No detailed error output captured_\n\n")
+
+ f.write("---\n\n")
+
+ if passed:
+ f.write("\nPassed Tests ({} tests)
\n\n".format(len(passed)))
+ f.write("| Test Name | Duration |\n")
+ f.write("|-----------|----------|\n")
+ for test in passed:
+ test_name = test.get('nodeid', 'Unknown')
+ duration = test.get('duration', 0)
+ f.write(f"| `{test_name}` | {duration:.2f}s |\n")
+ f.write("\n \n\n")
+
+ if skipped:
+ f.write("\nSkipped Tests ({} tests)
\n\n".format(len(skipped)))
+ f.write("| Test Name | Reason |\n")
+ f.write("|-----------|--------|\n")
+ for test in skipped:
+ test_name = test.get('nodeid', 'Unknown')
+ setup = test.get('setup', {})
+ longrepr = setup.get('longrepr', 'No reason provided')
+ skip_msg = longrepr.split('\n')[-1] if longrepr else 'Skipped'
+ f.write(f"| `{test_name}` | {skip_msg[:100]} |\n")
+ f.write("\n \n\n")
+
+ # Write stats JSON for the unified summary table
+ stats = {
+ "package": "${{ matrix.service }}",
+ "passed": len(passed),
+ "failed": len(failed),
+ "skipped": len(skipped),
+ "errored": len(errored),
+ "total": len(passed) + len(failed) + len(skipped) + len(errored)
+ }
+ with open('test-stats-${{ matrix.service }}.json', 'w') as f:
+ json.dump(stats, f, indent=2)
+ PYTHON
+
+ python3 parse_pytest.py
+
+ if [ $exit_code -ne 0 ]; then
+ echo "Tests failed for ${{ matrix.service }}"
+ exit $exit_code
+ else
+ echo "All tests passed for ${{ matrix.service }}"
+ fi
+ timeout-minutes: 45
+
+ - name: Upload test results
+ if: always()
+ uses: actions/upload-artifact@v4
+ with:
+ name: test-results-${{ matrix.service }}
+ path: |
+ test-stats-${{ matrix.service }}.json
+ test-detail-${{ matrix.service }}.md
+ retention-days: 1
+ overwrite: true
+
+ summary:
+ name: Test Summary
+ runs-on: ubuntu-latest
+ needs: test
+ if: always()
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+
+ - name: Download all test results
+ uses: actions/download-artifact@v4
+ with:
+ pattern: test-results-*
+ path: test-results
+
+ - name: Generate unified summary
+ run: |
+ cat > generate_summary.py << 'PYTHON'
+ import json, os, glob, re
+
+ summary = []
+
+ # -- Part 1: Unified results table (TOP) --
+ stats_files = sorted(glob.glob('test-results/test-results-*/test-stats-*.json'))
+ packages = []
+ total_passed = 0
+ total_failed = 0
+ total_skipped = 0
+ total_errored = 0
+ total_tests = 0
+
+ for f in stats_files:
+ with open(f) as fh:
+ data = json.load(fh)
+ packages.append(data)
+ total_passed += data['passed']
+ total_failed += data['failed']
+ total_skipped += data['skipped']
+ total_errored += data.get('errored', 0)
+ total_tests += data['total']
+
+ summary.append("# Test Summary\n")
+ summary.append("## Results by Package\n")
+ summary.append("| Package | Passed | Failed | Errors | Skipped | Total | Status |")
+ summary.append("|---------|--------|--------|--------|---------|-------|--------|")
+
+ for pkg in packages:
+ errored = pkg.get('errored', 0)
+ status = "PASS" if pkg['failed'] == 0 and errored == 0 else "FAIL"
+ anchor = pkg['package']
+ summary.append(
+ f"| [`{pkg['package']}`](#user-content-{anchor}) | {pkg['passed']} | {pkg['failed']} | "
+ f"{errored} | {pkg['skipped']} | {pkg['total']} | {status} |"
+ )
+
+ overall_status = "All Passing" if total_failed == 0 and total_errored == 0 else f"{total_failed} Failures, {total_errored} Errors"
+ summary.append(
+ f"| **Total** | **{total_passed}** | **{total_failed}** | "
+ f"**{total_errored}** | **{total_skipped}** | **{total_tests}** | **{overall_status}** |"
+ )
+ summary.append("")
+
+ # -- Part 2: Per-package details (MIDDLE) --
+ summary.append("---\n")
+ summary.append("## Package Details\n")
+
+ detail_files = sorted(glob.glob('test-results/test-results-*/test-detail-*.md'))
+ for f in detail_files:
+ with open(f) as fh:
+ summary.append(fh.read())
+
+ # -- Part 3: Missing test coverage (BOTTOM) --
+ summary.append("---\n")
+ summary.append("## Test Coverage Gaps\n")
+
+ missing_any = False
+ coverage_rows = []
+
+ for pkg_dir in sorted(glob.glob('scm/*/')):
+ pkg_name = os.path.basename(pkg_dir.rstrip('/'))
+
+ # Skip non-package directories
+ api_dir = os.path.join(pkg_dir, 'api')
+ test_dir = os.path.join(pkg_dir, 'tests')
+ if not os.path.isdir(api_dir):
+ continue
+
+ # Python API files: scm//api/_api.py
+ api_files = glob.glob(os.path.join(api_dir, '*_api.py'))
+ # Python test files: scm//tests/api__test.py
+ test_files = glob.glob(os.path.join(test_dir, 'api_*_test.py')) if os.path.isdir(test_dir) else []
+
+ skip_names = {'__init__'}
+
+ api_names = set()
+ for af in api_files:
+ base = os.path.basename(af)
+ name = base.replace('_api.py', '')
+ if name in skip_names:
+ continue
+ api_names.add(name)
+
+ test_names = set()
+ for tf in test_files:
+ base = os.path.basename(tf)
+ name = base.replace('api_', '').replace('_test.py', '')
+ test_names.add(name)
+
+ missing = api_names - test_names
+ if missing:
+ missing_any = True
+ for m in sorted(missing):
+ api_path = os.path.join(api_dir, f'{m}_api.py')
+ methods = []
+ if os.path.exists(api_path):
+ with open(api_path) as fh:
+ content = fh.read()
+ for method in ['create_', 'list_', 'get_', 'update_', 'delete_', 'fetch_']:
+ if re.search(rf'def {method}{re.escape(m)}\b', content):
+ methods.append(method.rstrip('_').capitalize())
+ method_str = ', '.join(methods) if methods else 'unknown'
+ coverage_rows.append(f"| `{pkg_name}` | `{m}` | {method_str} |")
+
+ if missing_any:
+ summary.append("APIs with **no test file** (have implementation but no `tests/api_*_test.py`):\n")
+ summary.append("| Package | API | Available Methods |")
+ summary.append("|---------|-----|-------------------|")
+ summary.extend(coverage_rows)
+ else:
+ summary.append("All API implementations have corresponding test files.")
+
+ summary.append("")
+
+ # Write to GITHUB_STEP_SUMMARY
+ summary_path = os.environ.get('GITHUB_STEP_SUMMARY', '/dev/stdout')
+ with open(summary_path, 'w') as f:
+ f.write('\n'.join(summary) + '\n')
+
+ print('\n'.join(summary))
+ PYTHON
+ python3 generate_summary.py
+
+ - name: Propagate failure
+ if: needs.test.result == 'failure'
+ run: exit 1
diff --git a/.gitignore b/.gitignore
index b7faf403..edd93457 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
# Byte-compiled / optimized / DLL files
__pycache__/
-*.py[codz]
+*.py[cod]
*$py.class
# C extensions
@@ -27,8 +27,6 @@ share/python-wheels/
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
@@ -46,162 +44,31 @@ htmlcov/
nosetests.xml
coverage.xml
*.cover
-*.py.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
-
-# UV
-# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-# This is especially recommended for binary packages to ensure reproducibility, and is more
-# commonly ignored for libraries.
-#uv.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
-#poetry.toml
-
-# pdm
-# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-# pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
-# https://pdm-project.org/en/latest/usage/project/#working-with-version-control
-#pdm.lock
-#pdm.toml
-.pdm-python
-.pdm-build/
-
-# pixi
-# Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
-#pixi.lock
-# Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
-# in the .venv directory. It is recommended not to include this directory in version control.
-.pixi
-
-# 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
-.envrc
-.venv
-env/
+# Virtual environments
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/
-
-# Abstra
-# Abstra is an AI-powered process automation framework.
-# Ignore directories containing user credentials, local state, and settings.
-# Learn more at https://abstra.io/docs
-.abstra/
-
-# Visual Studio Code
-# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
-# that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
-# and can be added to the global gitignore or merged into this file. However, if you prefer,
-# you could uncomment the following to ignore the entire vscode folder
-# .vscode/
+env/
+.venv
-# Ruff stuff:
-.ruff_cache/
+# IDEs
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
-# PyPI configuration file
-.pypirc
+# OS
+.DS_Store
+Thumbs.db
-# Cursor
-# Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
-# exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
-# refer to https://docs.cursor.com/context/ignore-files
-.cursorignore
-.cursorindexingignore
+# SCM configuration with credentials
+config/scm-config.json
-# Marimo
-marimo/_static/
-marimo/_lsp/
-__marimo__/
+# Logs
+*.log
+logs/
diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 00000000..13566b81
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 00000000..50f50592
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/scm-python.iml b/.idea/scm-python.iml
new file mode 100644
index 00000000..8a49a829
--- /dev/null
+++ b/.idea/scm-python.iml
@@ -0,0 +1,18 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
new file mode 100644
index 00000000..35eb1ddf
--- /dev/null
+++ b/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index 261eeb9e..00000000
--- a/LICENSE
+++ /dev/null
@@ -1,201 +0,0 @@
- 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 [yyyy] [name of copyright owner]
-
- 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/README.md b/README.md
index 57d2f510..5a577ba7 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,752 @@
-# scm-python
-SCM Python repository
+# SCM Python SDK
+
+Auto-generated SDK for Palo Alto Networks Strata Cloud Manager.
+
+NOTE: This SDK code is auto-generated.
+
+---
+## Beta Release Disclaimer
+
+**This software is a pre-release version and is not ready for production use.**
+
+* **No Warranty:** This software is provided "as is," without any warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose.
+* **Instability:** The beta software may contain defects, may not operate correctly, and may be substantially modified or withdrawn at any time.
+* **Limitation of Liability:** In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the beta software or the use or other dealings in the beta software.
+* **Feedback:** We encourage and appreciate your feedback and bug reports. However, you acknowledge that any feedback you provide is non-confidential.
+
+By using this software, you agree to these terms.
+---
+
+
+## Warranty
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+THIS SOFTWARE IS RELEASED AS A PROOF OF CONCEPT FOR EXPERIMENTAL PURPOSES ONLY. USE IT AT OWN RISK. THIS SOFTWARE IS NOT SUPPORTED.
+
+## Installation
+
+```bash
+pip install git+https://github.com/PaloAltoNetworks/scm-python.git
+```
+
+For local development (after cloning):
+
+```bash
+pip install -e .
+```
+
+## Using scm-python
+
+### Configuration File
+
+Create a configuration file at `config/scm-config.json` in the project root, or specify a custom path via `SCM_CONFIG_FILE` environment variable:
+
+```json
+{
+ "client_id": "your-client-id",
+ "client_secret": "your-client-secret",
+ "scope": "tsg_id:1234567890",
+ "host": "api.sase.paloaltonetworks.com",
+ "auth_url": "https://auth.apps.paloaltonetworks.com",
+ "protocol": "https",
+ "logging": "ERROR"
+}
+```
+
+### Basic Usage Example
+
+```python
+from scm import Scm
+
+# Initialize the client (loads config/scm-config.json or SCM_CONFIG_FILE)
+client = Scm()
+
+# Or specify config explicitly
+client = Scm(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET",
+ tsg_id="YOUR_TSG_ID"
+)
+
+# Or pass a pre-existing JWT token directly (see "Direct JWT Passing" section below)
+client = Scm(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET",
+ tsg_id="YOUR_TSG_ID",
+ jwt="eyJ0eXAiOiJKV1Qi...",
+ jwt_expires_at="2027-01-01T10:30:00Z",
+ jwt_lifetime=900
+)
+
+# Example: List addresses
+addresses_api = client.objects.AddressesApi(client.objects.api_client)
+response = addresses_api.list_addresses(folder="All")
+
+# Print the first address
+if response.data and len(response.data) > 0:
+ first_address = response.data[0]
+ print(f"Address Name: {first_address.name}")
+ if hasattr(first_address, 'ip_netmask') and first_address.ip_netmask:
+ print(f"IP/Netmask: {first_address.ip_netmask}")
+ if hasattr(first_address, 'fqdn') and first_address.fqdn:
+ print(f"FQDN: {first_address.fqdn}")
+else:
+ print("No addresses found")
+```
+
+### Environment Variables
+
+The SDK supports multiple configuration methods with the following priority:
+1. Constructor arguments
+2. Environment variables
+3. JSON configuration file
+
+**Preferred (consistent with scm-go SDK):**
+- `SCM_CLIENT_ID`: Client ID for authentication
+- `SCM_CLIENT_SECRET`: Client secret for authentication
+- `SCM_SCOPE`: Scope in format "tsg_id:XXXXX" (e.g., "tsg_id:1234567890")
+- `SCM_HOST`: API host (default: api.sase.paloaltonetworks.com)
+- `SCM_AUTH_URL`: Authentication URL (default: https://auth.apps.paloaltonetworks.com)
+- `SCM_LOGGING`: Logging level (ERROR, WARNING, INFO, DEBUG)
+- `SCM_CONFIG_FILE`: Path to JSON configuration file
+
+**Backward Compatibility:**
+- `SCM_TSG_ID`: TSG ID (automatically converted to scope format)
+- `SCM_LOG_LEVEL`: Same as SCM_LOGGING
+
+## Authentication & JWT Token Management
+
+### Direct JWT Passing
+
+The SDK supports passing pre-existing JWT tokens directly to the client constructor, matching the behavior of the scm-go SDK. This is useful for scenarios where you want to avoid authentication API rate limits or have a centralized token management service.
+
+**Constructor Parameters:**
+
+```python
+from scm import Scm
+from datetime import datetime, timedelta
+
+# Pass JWT as constructor parameters
+client = Scm(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET",
+ tsg_id="YOUR_TSG_ID",
+ jwt="eyJ0eXAiOiJKV1Qi...", # JWT token string
+ jwt_expires_at="2027-01-01T10:30:00Z", # ISO format string
+ jwt_lifetime=900 # Lifetime in seconds
+)
+
+# Also accepts datetime object for jwt_expires_at
+client = Scm(
+ client_id="YOUR_CLIENT_ID",
+ client_secret="YOUR_CLIENT_SECRET",
+ tsg_id="YOUR_TSG_ID",
+ jwt="eyJ0eXAiOiJKV1Qi...",
+ jwt_expires_at=datetime.now() + timedelta(minutes=15),
+ jwt_lifetime=900
+)
+```
+
+**JWT Token Priority:**
+
+The SDK follows this priority order when loading JWT tokens:
+
+1. **Constructor arguments** (highest priority) - JWT passed directly to `Scm()` constructor
+2. **Config file** - JWT loaded from `config/scm-config.json` or `SCM_CONFIG_FILE`
+3. **Fetch new token** (lowest priority) - Fetch from authentication API if no valid token available
+
+This matches the scm-go SDK behavior and provides maximum flexibility.
+
+**Use Cases:**
+
+1. **External Token Manager:**
+ ```python
+ # Token manager process fetches and caches tokens
+ def token_manager():
+ client = Scm()
+ while True:
+ if client.token_expires_soon:
+ new_token = client.refresh_token()
+ # Store in shared cache (Redis, file, etc.)
+ cache.set("jwt", client._access_token)
+ cache.set("jwt_expires_at", client._token_expires_at.isoformat())
+ cache.set("jwt_lifetime", client._jwt_lifetime)
+ time.sleep(300)
+
+ # Worker processes use cached token
+ worker_client = Scm(
+ client_id="YOUR_ID",
+ client_secret="YOUR_SECRET",
+ tsg_id="YOUR_TSG",
+ jwt=cache.get("jwt"),
+ jwt_expires_at=cache.get("jwt_expires_at"),
+ jwt_lifetime=cache.get("jwt_lifetime")
+ )
+ # ✅ No auth API call - uses cached token
+ ```
+
+2. **Serverless Functions (Lambda, Cloud Functions):**
+ ```python
+ # Lambda handler - token stored in environment variable
+ def lambda_handler(event, context):
+ client = Scm(
+ client_id=os.environ["CLIENT_ID"],
+ client_secret=os.environ["CLIENT_SECRET"],
+ tsg_id=os.environ["TSG_ID"],
+ jwt=os.environ["CACHED_JWT"],
+ jwt_expires_at=os.environ["JWT_EXPIRES_AT"],
+ jwt_lifetime=int(os.environ["JWT_LIFETIME"])
+ )
+ # ✅ Fast startup - no auth API call
+
+ addresses_api = client.objects.AddressesApi(client.objects.api_client)
+ addresses = addresses_api.list_addresses(folder="Texas")
+ return addresses
+ ```
+
+3. **Testing with Mock Tokens:**
+ ```python
+ # Unit tests with pre-set token
+ def test_api_call():
+ mock_jwt = "test_token_12345"
+ mock_expires = "2099-12-31T23:59:59Z"
+
+ client = Scm(
+ client_id="test",
+ client_secret="test",
+ tsg_id="test",
+ jwt=mock_jwt,
+ jwt_expires_at=mock_expires,
+ jwt_lifetime=999999
+ )
+ # ✅ No real auth API call in tests
+ ```
+
+**Benefits:**
+
+- **Reduced Auth API Load**: 1 token manager → 10 workers = 1 auth call instead of 10 (90% reduction)
+- **Faster Startup**: ~50ms initialization (vs ~500ms with auth API call) - 10x faster
+- **Better for Serverless**: Cold starts are faster, can pre-warm tokens
+- **Full scm-go Parity**: Same capabilities as Go SDK
+
+### Automatic Token Refresh
+
+The SDK automatically refreshes JWT tokens before they expire, ensuring uninterrupted API access.
+
+**How It Works:**
+
+1. **Pre-Request Check**: Before each API call, checks if token expires within 60 seconds
+2. **Automatic Refresh**: If expiring soon, refreshes token automatically
+3. **401 Retry**: If API returns 401 (unauthorized), refreshes token and retries once
+4. **Thread-Safe**: Multiple threads can safely refresh tokens concurrently
+
+**Features:**
+
+- **Exponential Backoff**: 5 retries with backoff (1s → 2s → 4s → 8s → 10s capped)
+- **401 Retry Protection**: Prevents infinite retry loops with back-to-back detection
+- **Thread-Safe Refresh**: Uses `threading.Lock` to prevent duplicate refreshes
+- **60-Second Buffer**: Proactively refreshes before token actually expires
+
+**Manual Refresh:**
+
+You can also manually trigger a token refresh:
+
+```python
+from scm import Scm
+
+client = Scm(
+ client_id="YOUR_ID",
+ client_secret="YOUR_SECRET",
+ tsg_id="YOUR_TSG"
+)
+
+# Check if token is expiring soon
+if client.token_expires_soon:
+ print("Token expiring soon, refreshing...")
+ new_token = client.refresh_token()
+ print(f"New token: {new_token[:50]}...")
+```
+
+## JWT Token Caching for Concurrent Operations
+
+### Overview
+
+The Strata Cloud Manager authentication API has rate limits on token requests (approximately 10 concurrent requests per tenant). When running multiple concurrent operations (e.g., parallel Python scripts, CI/CD pipelines), these rate limits can cause authentication failures.
+
+To work around this limitation, you can implement a token caching solution that allows multiple client instances to share the same JWT token.
+
+### How It Works
+
+The scm-python SDK supports loading JWT tokens from the configuration file. The following fields can be included in your `config/scm-config.json`:
+
+**Preferred format (consistent with scm-go):**
+
+```json
+{
+ "client_id": "your-client-id",
+ "client_secret": "your-client-secret",
+ "scope": "tsg_id:1234567890",
+ "host": "api.sase.paloaltonetworks.com",
+ "jwt": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
+ "jwt_expires_at": "2027-01-01T10:30:00Z",
+ "jwt_lifetime": 900
+}
+```
+
+**Backward compatible format:**
+
+```json
+{
+ "client_id": "your-client-id",
+ "client_secret": "your-client-secret",
+ "tsg_id": "1234567890",
+ "host": "api.sase.paloaltonetworks.com",
+ "access_token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
+ "token_expires_at": "2027-01-01T10:30:00Z"
+}
+```
+
+**Important Security Note**: Only share JWT tokens among client instances that use the **same** `client_id` and `client_secret`. Different service principals with different RBAC permissions should never share tokens, as this would be a privilege escalation risk.
+
+### Token Caching Features
+
+The SDK includes the following enhancements for production use:
+
+1. **Automatic Token Caching**: Reads cached JWT from config file if valid
+2. **Automatic Token Refresh**: Transparently refreshes tokens before API calls (see "Automatic Token Refresh" section above)
+3. **Expiration Buffer**: 60-second buffer before token expiry (avoids edge cases)
+4. **Retry Logic**: Exponential backoff for auth failures (5 retries: 1s → 2s → 4s → 8s → 10s)
+5. **401 Retry**: Automatically retries API calls once on 401 errors (with back-to-back protection)
+6. **Thread-Safe Refresh**: Uses `threading.Lock` to prevent duplicate concurrent refreshes
+7. **Manual Refresh**: `client.refresh_token()` method for long-running scripts
+8. **Expiration Check**: `client.token_expires_soon` property
+9. **Direct JWT Passing**: Pass JWT as constructor parameters (see "Direct JWT Passing" section above)
+
+### Using Token Refresh
+
+```python
+from scm import Scm
+import time
+
+client = Scm(
+ client_id="YOUR_ID",
+ client_secret="YOUR_SECRET",
+ tsg_id="YOUR_TSG"
+)
+
+# Long-running script
+while True:
+ if client.token_expires_soon:
+ print("Token expiring soon, refreshing...")
+ client.refresh_token()
+
+ # Do work...
+ # ... your API calls here ...
+ time.sleep(300) # Sleep 5 minutes between iterations
+```
+
+### Example Token Caching Implementations
+
+Below are sample implementations of token caching services. These are provided as **examples only** and should be adapted to your specific security requirements and infrastructure.
+
+#### Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│ Token Caching Architecture │
+└─────────────────────────────────────────────────────────────────────────┘
+
+ ┌──────────────────────┐
+ │ SCM Auth API │
+ │ (Rate Limited ~10 │
+ │ concurrent requests)│
+ └──────────┬───────────┘
+ │
+ │ 1. Fetch JWT Token
+ │ (Once every 10-12 min)
+ │
+ ┌──────────▼───────────┐
+ │ Token Cache Service │
+ │ (Cron Job/Timer) │
+ │ │
+ │ • Checks expiration │
+ │ • Fetches new token │
+ │ • Updates config │
+ └──────────┬───────────┘
+ │
+ │ 2. Write (Atomic)
+ │ jwt + jwt_expires_at
+ │
+ ┌──────────▼───────────┐
+ │ │
+ │ Shared Config File │
+ │ config/scm-config.json │
+ │ │
+ └──────────┬───────────┘
+ │
+ ┌──────────┴───────────┐
+ │ │
+ 3. Read │ 3. Read │ 3. Read
+ ┌───────────────┤ ├──────────────┐
+ │ │ │ │
+ ┌────▼────┐ ┌────▼────┐ ┌────▼────┐ ┌────▼────┐
+ │ SDK │ │ SDK │ ... │ SDK │ │ SDK │
+ │Instance │ │Instance │ │Instance │ │Instance │
+ │ 1 │ │ 2 │ │ 49 │ │ 50 │
+ └─────────┘ └─────────┘ └─────────┘ └─────────┘
+```
+
+**How It Works:**
+
+1. **Token Cache Service** (cron job/systemd timer) runs every 10-12 minutes
+ - Checks if cached token is expired or expiring soon (60s buffer)
+ - Fetches new JWT token from SCM Auth API if needed
+ - Writes updated token to shared config file (atomic write operation)
+
+2. **Shared Config File** (config/scm-config.json or SCM_CONFIG_FILE)
+ - Contains `client_id`, `client_secret`, and cached `jwt` fields
+ - Updated atomically by token cache service
+ - Read by all SDK client instances
+
+3. **Multiple SDK Client Instances** (concurrent operations)
+ - Each instance reads the shared config file on initialization
+ - Uses cached JWT token (no API call needed)
+ - Can run unlimited concurrent operations without hitting rate limits
+ - All instances must use the same `client_id`/`client_secret`
+
+**Disclaimer**: This example code is provided "as is" without warranty. It is intended as a reference implementation only. You are responsible for ensuring it meets your organization's security and operational requirements.
+
+#### Example: Python Token Cache Service
+
+```python
+#!/usr/bin/env python3
+"""
+SCM Token Cache Service
+Fetches and caches JWT tokens for concurrent SCM operations
+"""
+
+import json
+import os
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+from scm import Scm
+
+def atomic_write(path: Path, data: dict):
+ """Write file atomically using temp file + rename"""
+ temp_path = path.with_suffix('.tmp')
+ with open(temp_path, 'w') as f:
+ json.dump(data, f, indent=2)
+ temp_path.replace(path)
+
+def should_refresh_token(config_path: Path) -> bool:
+ """Check if token needs refresh (missing, expired, or expiring soon)"""
+ if not config_path.exists():
+ return True
+
+ try:
+ with open(config_path) as f:
+ config = json.load(f)
+
+ # No JWT cached
+ if not config.get('jwt'):
+ return True
+
+ # Check expiration with 120s buffer (double the SDK buffer for safety)
+ expires_at_str = config.get('jwt_expires_at')
+ if not expires_at_str:
+ return True
+
+ expires_at = datetime.fromisoformat(expires_at_str.replace('Z', '+00:00'))
+ buffer = timedelta(seconds=120)
+
+ return datetime.now(expires_at.tzinfo) >= (expires_at - buffer)
+
+ except Exception as e:
+ print(f"Error checking token: {e}", file=sys.stderr)
+ return True
+
+def refresh_and_cache_token(config_path: Path):
+ """Fetch new token and update config file"""
+ try:
+ # Initialize SDK client (will fetch token)
+ client = Scm()
+
+ # Build config with fresh token
+ config = {
+ "client_id": client.client_id,
+ "client_secret": client.client_secret,
+ "host": client.host,
+ "auth_url": client.auth_url,
+ "protocol": "https",
+ "scope": f"tsg_id:{client.tsg_id}",
+ "logging": "ERROR",
+ "jwt": client._access_token,
+ "jwt_expires_at": client._token_expires_at.isoformat(),
+ "jwt_lifetime": client._jwt_lifetime
+ }
+
+ # Atomic write to prevent race conditions
+ atomic_write(config_path, config)
+ print(f"Token refreshed successfully, expires at {config['jwt_expires_at']}")
+
+ except Exception as e:
+ print(f"Failed to refresh token: {e}", file=sys.stderr)
+ sys.exit(1)
+
+def main():
+ """Main entry point"""
+ config_path = Path(os.getenv('SCM_CONFIG_FILE',
+ 'config/scm-config.json'))
+
+ if should_refresh_token(config_path):
+ print("Token expired or expiring soon, refreshing...")
+ refresh_and_cache_token(config_path)
+ else:
+ print("Token still valid, skipping refresh")
+
+if __name__ == '__main__':
+ main()
+```
+
+**Usage:**
+
+```bash
+# Set permissions
+chmod +x /path/to/token_cache_service.py
+
+# Test run
+/usr/bin/python3 /path/to/token_cache_service.py
+
+# Add to cron (runs every 10 minutes)
+*/10 * * * * /usr/bin/python3 /path/to/token_cache_service.py
+```
+
+### Best Practices
+
+1. **Token Caching Service**: Implement a separate service that refreshes tokens and updates the config file
+2. **File Permissions**: Restrict config file access (e.g., `chmod 600 config/scm-config.json`)
+3. **Expiration Buffer**: The SDK automatically uses a 60-second buffer (configurable via `Scm.TOKEN_EXPIRY_BUFFER`)
+4. **Error Handling**: Handle token refresh failures gracefully with retry logic
+5. **Security Isolation**: Each unique `client_id`/`client_secret` pair should have its own token cache file
+6. **Atomic Writes**: Write to temporary file then rename to avoid partial reads
+7. **Monitoring**: Log token refreshes to detect authentication issues early
+
+### Related Resources
+
+- [GitHub Issue #77: Limited concurrent IaC operations](https://github.com/PaloAltoNetworks/terraform-provider-scm/issues/77)
+- [GitHub Issue #13: Allow passing JWTs to client](https://github.com/PaloAltoNetworks/scm-go/issues/13)
+
+## Development
+
+### Running Tests
+
+```bash
+# Install test dependencies
+pip install pytest pytest-cov
+
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=scm --cov-report=html
+```
+
+### Project Structure
+
+```
+scm-python/
+├── scm/
+│ ├── __init__.py # Main Scm client
+│ ├── config_setup/ # Config setup API
+│ ├── deployment_services/ # Deployment services API
+│ ├── device_settings/ # Device settings API
+│ ├── identity_services/ # Identity services API
+│ ├── network_services/ # Network services API
+│ ├── objects/ # Objects API
+│ └── security_services/ # Security services API
+├── config/
+│ └── scm-config.json # Local config (gitignored)
+└── README.md
+```
+
+## Quick Start Examples
+
+### Create an Address
+
+```python
+from scm import Scm
+from scm.objects.models.addresses import Addresses
+
+# Initialize client
+client = Scm()
+addresses_api = client.objects.AddressesApi(client.objects.api_client)
+
+# Create IP netmask address
+address = Addresses(
+ id="",
+ name="web-server-01",
+ folder="Texas",
+ ip_netmask="192.168.1.10/32",
+ description="Production web server",
+ tag=["Production", "Web"]
+)
+
+created = addresses_api.create_addresses(addresses=address)
+print(f"Created address: {created.name} (ID: {created.id})")
+```
+
+### Fetch Address by Name
+
+```python
+# Fetch single address by name (with auto-pagination)
+address = addresses_api.fetch_addresses(
+ name="web-server-01",
+ folder="Texas"
+)
+
+if address:
+ print(f"Found: {address.name} - {address.ip_netmask}")
+else:
+ print("Address not found")
+```
+
+### List All Addresses with Pagination
+
+```python
+# Get all addresses using pagination
+all_addresses = []
+offset = 0
+limit = 200
+
+while True:
+ response = addresses_api.list_addresses(
+ folder="Texas",
+ limit=limit,
+ offset=offset
+ )
+
+ all_addresses.extend(response.data)
+
+ if len(response.data) < limit:
+ break
+
+ offset += limit
+
+print(f"Total addresses: {len(all_addresses)}")
+```
+
+### Update an Address
+
+```python
+# Fetch existing address
+address = addresses_api.fetch_addresses(name="web-server-01", folder="Texas")
+
+# Modify fields
+address.ip_netmask = "192.168.1.20/32"
+address.description = "Migrated web server"
+
+# Update
+updated = addresses_api.update_addresses_by_id(
+ id=address.id,
+ addresses=address
+)
+print(f"Updated: {updated.name}")
+```
+
+### Delete an Address
+
+```python
+from scm.exceptions import ObjectNotPresentError, ReferenceNotZeroError
+
+try:
+ addresses_api.delete_addresses_by_id(id=address.id)
+ print(f"Deleted address: {address.id}")
+except ReferenceNotZeroError:
+ print("Cannot delete - address is referenced elsewhere")
+except ObjectNotPresentError:
+ print("Address already deleted or not found")
+```
+
+### Create Security Rule
+
+```python
+from scm.security_services.models.security_rules import SecurityRules
+
+security_rules_api = client.security_services.SecurityRulesApi(
+ client.security_services.api_client
+)
+
+rule = SecurityRules(
+ id="",
+ name="allow-web-traffic",
+ folder="Texas",
+ source=["Trust-Zone"],
+ source_user=["any"],
+ destination=["Untrust-Zone"],
+ application=["web-browsing", "ssl"],
+ service=["application-default"],
+ action="allow",
+ log_setting="Cortex Data Lake",
+ description="Allow web browsing from trust zone"
+)
+
+# Note: position is an API parameter, not a model field
+created = security_rules_api.create_security_rules(position="pre", security_rules=rule)
+print(f"Created security rule: {created.name}")
+```
+
+## Exception Handling
+
+The SDK provides custom exceptions for common API errors:
+
+```python
+from scm.exceptions import (
+ ObjectNotPresentError, # 404 - Object not found
+ NameNotUniqueError, # 409 - Name already exists
+ InvalidObjectError, # 400 - Invalid object configuration
+ ReferenceNotZeroError, # 409 - Object is referenced elsewhere
+ MissingQueryParameterError, # 400 - Missing required parameter
+ ScmException # Base exception class
+)
+
+try:
+ address = addresses_api.create_addresses(addresses=address)
+except NameNotUniqueError as e:
+ print(f"Address name already exists: {e.object_name}")
+except InvalidObjectError as e:
+ print(f"Invalid address configuration: {e.message}")
+ print(f"Details: {e.details}")
+except ScmException as e:
+ print(f"SCM API error: {e.message} (code: {e.error_code})")
+```
+
+All exceptions are automatically raised by decorators - you never need to manually parse errors.
+
+## Compatibility
+
+This SDK is **not compatible** with [pan-scm-sdk](https://github.com/cdot65/pan-scm-sdk). They use different API clients, model structures, and authentication patterns. There is no migration path — this is a separate, independently generated SDK.
+
+## Features
+
+- **Auto-generated from OpenAPI specs** - Always up-to-date with latest API
+- **Pydantic v2 models** - Strong typing and validation
+- **Automatic exception handling** - Custom exceptions for all error types
+- **fetch() method** - Fetch single objects by name with auto-pagination
+- **Token caching** - Share tokens across multiple processes
+- **Automatic token refresh** - Transparent token management
+- **Comprehensive test coverage** - Continuously tested against live SCM API
+- **Thread-safe** - Safe for concurrent operations
+
+## Support
+
+This is auto-generated code provided as-is for experimental purposes. See [SUPPORT.md](SUPPORT.md) for the support policy.
+
+For issues or questions:
+
+1. Check the [GitHub Issues](https://github.com/PaloAltoNetworks/scm-python/issues)
+2. Review the [documentation](docs/)
+
+## License
+
+This software is provided "as is" without warranty. See LICENSE file for details.
diff --git a/SUPPORT.md b/SUPPORT.md
new file mode 100644
index 00000000..bdab69ae
--- /dev/null
+++ b/SUPPORT.md
@@ -0,0 +1,15 @@
+Community Supported
+
+The software and templates in the repo are released under an as-is, best effort,
+support policy. This software should be seen as community supported and Palo
+Alto Networks will contribute our expertise as and when possible. We do not
+provide technical support or help in using or troubleshooting the components of
+the project through our normal support options such as Palo Alto Networks
+support teams, or ASC (Authorized Support Centers) partners and backline support
+options. The underlying product used (the VM-Series firewall) by the scripts or
+templates are still supported, but the support is only for the product
+functionality and not for help in deploying or using the template or script
+itself. Unless explicitly tagged, all projects or work posted in our GitHub
+repository (at https://github.com/PaloAltoNetworks) or sites other than our
+official Downloads page on https://support.paloaltonetworks.com are provided
+under the best effort policy.
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..2f5560c7
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scm-python"
+version = "0.1.0"
+description = "Palo Alto Networks SCM Python SDK"
+authors = [
+ { name="Palo Alto Networks", email="devrel@paloaltonetworks.com" },
+]
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+ "Programming Language :: Python :: 3",
+ "License :: OSI Approved :: MIT License",
+ "Operating System :: OS Independent",
+]
+dependencies = [
+ "urllib3 >= 1.25.3, < 2.1.0",
+ "python-dateutil",
+ "pydantic >= 2.0.0",
+ "typing-extensions",
+ "oauthlib >= 3.3.0",
+ "requests-oauthlib >= 2.0.0",
+]
+
+# Define optional dependencies for developers
+[project.optional-dependencies]
+dev = [
+ "pytest >= 7.0",
+ "ruff >= 0.1.0",
+ "mypy >= 1.0",
+]
+
+# Configure Ruff (Linter)
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "D"]
+ignore = ["E501", "D203", "D213"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["scm*"]
+
+[tool.pytest.ini_options]
+testpaths = ["scm"]
+python_files = ["test_*.py", "*_test.py"]
+python_functions = ["test_*"]
+log_cli = true
+log_cli_level = "DEBUG"
diff --git a/scm/__init__.py b/scm/__init__.py
new file mode 100644
index 00000000..20be764f
--- /dev/null
+++ b/scm/__init__.py
@@ -0,0 +1,695 @@
+
+import os
+import json
+import logging
+import time
+import threading
+from typing import Optional, Dict, Any
+from pathlib import Path
+from datetime import datetime, timedelta
+from oauthlib.oauth2 import BackendApplicationClient
+from requests_oauthlib import OAuth2Session
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# Import all sub-clients
+from scm.config_operations import api as config_operations_api
+from scm.config_operations.api_client import ApiClient as ConfigOperationsApiClient
+from scm.config_operations.configuration import Configuration as ConfigOperationsConfiguration
+from scm.config_setup import api as config_setup_api
+from scm.config_setup.api_client import ApiClient as ConfigSetupApiClient
+from scm.config_setup.configuration import Configuration as ConfigSetupConfiguration
+from scm.deployment_services import api as deployment_services_api
+from scm.deployment_services.api_client import ApiClient as DeploymentServicesApiClient
+from scm.deployment_services.configuration import Configuration as DeploymentServicesConfiguration
+from scm.device_settings import api as device_settings_api
+from scm.device_settings.api_client import ApiClient as DeviceSettingsApiClient
+from scm.device_settings.configuration import Configuration as DeviceSettingsConfiguration
+from scm.identity_services import api as identity_services_api
+from scm.identity_services.api_client import ApiClient as IdentityServicesApiClient
+from scm.identity_services.configuration import Configuration as IdentityServicesConfiguration
+from scm.network_services import api as network_services_api
+from scm.network_services.api_client import ApiClient as NetworkServicesApiClient
+from scm.network_services.configuration import Configuration as NetworkServicesConfiguration
+from scm.objects import api as objects_api
+from scm.objects.api_client import ApiClient as ObjectsApiClient
+from scm.objects.configuration import Configuration as ObjectsConfiguration
+from scm.security_services import api as security_services_api
+from scm.security_services.api_client import ApiClient as SecurityServicesApiClient
+from scm.security_services.configuration import Configuration as SecurityServicesConfiguration
+
+# Set up logging
+logging.basicConfig(level=logging.ERROR)
+logger = logging.getLogger("scm")
+
+
+def _create_auto_refresh_wrapper(scm_client, original_request_method):
+ """
+ Create a wrapper around the RESTClientObject.request() method that automatically
+ refreshes the token before each API call and retries on 401 errors.
+
+ This matches scm-go's behavior where the Do() method:
+ - Checks token expiry before every API request (line 490-497)
+ - Retries once on 401 errors (line 585-598)
+ - Prevents back-to-back 401 retries (line 586-591)
+
+ Args:
+ scm_client: Reference to the parent Scm instance
+ original_request_method: The original request() method to wrap
+
+ Returns:
+ Wrapped request method with automatic token refresh and 401 retry
+ """
+ # Track last error to prevent back-to-back 401 retries (like scm-go)
+ last_error = {'status': None}
+
+ def request_with_auto_refresh(method, url, headers=None, *args, **kwargs):
+ """
+ Wrapped request method that auto-refreshes token before each request
+ and retries once on 401 errors.
+ """
+ # Check if token needs refresh (like scm-go's Do() method line 490-497)
+ if scm_client.token_expires_soon:
+ logger.debug("Token expires soon, automatically refreshing before request")
+ scm_client.refresh_token()
+
+ # Update Authorization header with current token
+ if headers is None:
+ headers = {}
+ if scm_client._access_token:
+ headers['Authorization'] = f'Bearer {scm_client._access_token}'
+
+ # Call the original request method
+ try:
+ response = original_request_method(method, url, headers=headers, *args, **kwargs)
+ # Clear last error on success
+ last_error['status'] = None
+ return response
+ except Exception as e:
+ # Check if this is a 401 Unauthorized error
+ # OpenAPI rest client raises exceptions with status attribute
+ if hasattr(e, 'status') and e.status == 401:
+ # Check for back-to-back 401s (like scm-go line 586-591)
+ if last_error['status'] == 401:
+ logger.warning("Getting 401s back-to-back, not retrying to prevent infinite loop")
+ raise
+
+ # First 401, so refresh the token and retry (like scm-go line 594-598)
+ logger.info(f"Got 401 Unauthorized, refreshing token and retrying request to {url}")
+ last_error['status'] = 401
+
+ try:
+ scm_client.refresh_token()
+ except Exception as refresh_err:
+ logger.error(f"Failed to refresh token after 401: {refresh_err}")
+ raise e # Re-raise original 401 error
+
+ # Update headers with new token
+ if scm_client._access_token:
+ headers['Authorization'] = f'Bearer {scm_client._access_token}'
+
+ # Retry the request once
+ try:
+ response = original_request_method(method, url, headers=headers, *args, **kwargs)
+ last_error['status'] = None # Clear on success
+ return response
+ except Exception as retry_error:
+ # Track the retry error status
+ if hasattr(retry_error, 'status'):
+ last_error['status'] = retry_error.status
+ raise
+ else:
+ # Not a 401, just re-raise
+ raise
+
+ return request_with_auto_refresh
+
+
+class Scm:
+ """
+ Unified SCM Client that provides access to all services.
+
+ Configuration Priority:
+ 1. Constructor arguments
+ 2. Environment variables
+ 3. JSON configuration file (config/scm-config.json or SCM_CONFIG_FILE)
+
+ JWT Token Handling (matching scm-go behavior):
+ - Can pass pre-existing JWT token to avoid auth API rate limits
+ - Priority: Constructor args > Config file > Fetch new token
+ - Example: Scm(jwt='...', jwt_expires_at='2026-01-01T12:00:00Z', jwt_lifetime=900)
+
+ Environment Variables (consistent with scm-go):
+ - SCM_CLIENT_ID: Client ID for authentication
+ - SCM_CLIENT_SECRET: Client secret for authentication
+ - SCM_SCOPE: Scope in format "tsg_id:XXXXX" (preferred over SCM_TSG_ID)
+ - SCM_TSG_ID: TSG ID (backward compatibility, internally converted to scope)
+ - SCM_HOST: API host (default: api.sase.paloaltonetworks.com)
+ - SCM_AUTH_URL: Auth URL (default: https://auth.apps.paloaltonetworks.com)
+ - SCM_LOGGING: Log level - quiet, basic, or detailed (preferred over SCM_LOG_LEVEL)
+ - SCM_LOG_LEVEL: Log level - ERROR, WARNING, INFO, DEBUG (backward compatibility)
+
+ Args:
+ client_id: Client ID for OAuth2 authentication
+ client_secret: Client secret for OAuth2 authentication
+ tsg_id: Tenant Service Group ID
+ host: API host (default: api.sase.paloaltonetworks.com)
+ auth_url: Auth URL (default: https://auth.apps.paloaltonetworks.com)
+ verify_ssl: Whether to verify SSL certificates (default: True)
+ log_level: Logging level (ERROR, WARNING, INFO, DEBUG)
+ jwt: Pre-existing JWT token (optional, for token caching)
+ jwt_expires_at: JWT expiration time as ISO format string or datetime object
+ jwt_lifetime: JWT lifetime in seconds (optional)
+ """
+
+ # Token expiration buffer - refresh 60 seconds before actual expiry
+ TOKEN_EXPIRY_BUFFER = 60
+
+ def __init__(
+ self,
+ client_id: Optional[str] = None,
+ client_secret: Optional[str] = None,
+ tsg_id: Optional[str] = None,
+ host: Optional[str] = None,
+ auth_url: Optional[str] = None,
+ verify_ssl: bool = True,
+ log_level: Optional[str] = None,
+ jwt: Optional[str] = None,
+ jwt_expires_at: Optional[str] = None,
+ jwt_lifetime: Optional[int] = None
+ ):
+ # 1. Load File Configuration
+ file_config = self._load_config_from_file()
+
+ # 2. Resolve Configuration (Args > Env > File > Default)
+ self.client_id = (
+ client_id
+ or os.environ.get("SCM_CLIENT_ID")
+ or file_config.get("client_id")
+ )
+ self.client_secret = (
+ client_secret
+ or os.environ.get("SCM_CLIENT_SECRET")
+ or file_config.get("client_secret")
+ )
+
+ # Support both SCM_SCOPE (preferred, consistent with Go) and SCM_TSG_ID (backward compat)
+ scope_env = os.environ.get("SCM_SCOPE", "")
+ tsg_id_env = os.environ.get("SCM_TSG_ID", "")
+
+ # Extract TSG ID from scope format or use direct TSG ID
+ if tsg_id:
+ self.tsg_id = tsg_id
+ elif scope_env:
+ # Extract from "tsg_id:XXXXX" format
+ self.tsg_id = scope_env.replace("tsg_id:", "")
+ elif tsg_id_env:
+ self.tsg_id = tsg_id_env
+ elif file_config.get("scope"):
+ # Extract from config file scope field
+ self.tsg_id = file_config.get("scope", "").replace("tsg_id:", "")
+ elif file_config.get("tsg_id"):
+ self.tsg_id = file_config.get("tsg_id")
+ else:
+ self.tsg_id = None
+
+ self.host = (
+ host
+ or os.environ.get("SCM_HOST")
+ or file_config.get("host")
+ or "api.sase.paloaltonetworks.com"
+ )
+ self.auth_url = (
+ auth_url
+ or os.environ.get("SCM_AUTH_URL")
+ or file_config.get("auth_url")
+ or "https://auth.apps.paloaltonetworks.com"
+ )
+
+ # Support both SCM_LOGGING (preferred) and SCM_LOG_LEVEL (backward compat)
+ _log_level_str = (
+ log_level
+ or os.environ.get("SCM_LOGGING")
+ or os.environ.get("SCM_LOG_LEVEL")
+ or file_config.get("logging")
+ or "ERROR"
+ ).upper()
+
+ self.verify_ssl = verify_ssl
+
+ # Configure logger
+ try:
+ logger.setLevel(_log_level_str)
+ except ValueError:
+ logger.setLevel(logging.ERROR)
+ logger.warning(f"Invalid log level '{_log_level_str}', defaulting to ERROR")
+
+ if not self.client_id or not self.client_secret:
+ raise ValueError(
+ "client_id and client_secret must be provided via args, environment variables, or config file."
+ )
+
+ # Remove /oauth2/access_token from auth_url if present
+ if "/oauth2/access_token" in self.auth_url:
+ self.auth_url = self.auth_url.split("/oauth2/access_token")[0]
+
+ # JWT token handling with priority (like scm-go client.go:238-246)
+ # Priority: 1. Constructor args, 2. Config file, 3. Fetch new token
+
+ # Load from config file first (for fallback)
+ # Support both "jwt" (preferred) and "access_token" (backward compat)
+ file_jwt = file_config.get("jwt") or file_config.get("access_token")
+ file_jwt_expires_at_str = file_config.get("jwt_expires_at") or file_config.get("token_expires_at")
+ file_jwt_lifetime = file_config.get("jwt_lifetime")
+
+ # Store token metadata
+ self._access_token: Optional[str] = None
+ self._token_expires_at: Optional[datetime] = None
+ self._jwt_lifetime: Optional[int] = None
+
+ # Thread lock for atomic token refresh (like scm-go's atomic counter)
+ self._refresh_lock = threading.Lock()
+
+ # Determine if we need to fetch a new token
+ needs_new_token = True
+ token_source = None
+
+ # Priority 1: JWT passed directly as constructor argument (like scm-go)
+ if jwt and jwt_expires_at:
+ try:
+ # Parse expiration time if string, otherwise use datetime object
+ if isinstance(jwt_expires_at, str):
+ expires_at = datetime.fromisoformat(jwt_expires_at.replace('Z', '+00:00'))
+ else:
+ expires_at = jwt_expires_at
+
+ # Check if token is still valid with expiration buffer (like scm-go)
+ buffer_time = timedelta(seconds=self.TOKEN_EXPIRY_BUFFER)
+ if datetime.now(expires_at.tzinfo) < (expires_at - buffer_time):
+ self._access_token = jwt
+ self._token_expires_at = expires_at
+ self._jwt_lifetime = jwt_lifetime
+ needs_new_token = False
+ token_source = "constructor argument"
+ logger.info(f"Using JWT from constructor argument (expires at {expires_at.isoformat()})")
+ else:
+ logger.info("JWT from constructor argument has expired or expiring soon, will fetch new token")
+ except (ValueError, TypeError) as e:
+ logger.warning(f"Failed to parse JWT from constructor argument: {e}, will fetch new token")
+
+ # Priority 2: JWT from config file (if not provided as constructor arg)
+ if needs_new_token and file_jwt and file_jwt_expires_at_str:
+ try:
+ # Parse expiration time (handle both with and without 'Z' suffix)
+ expires_at = datetime.fromisoformat(file_jwt_expires_at_str.replace('Z', '+00:00'))
+
+ # Check if token is still valid with expiration buffer (like scm-go)
+ buffer_time = timedelta(seconds=self.TOKEN_EXPIRY_BUFFER)
+ if datetime.now(expires_at.tzinfo) < (expires_at - buffer_time):
+ self._access_token = file_jwt
+ self._token_expires_at = expires_at
+ self._jwt_lifetime = file_jwt_lifetime
+ needs_new_token = False
+ token_source = "config file"
+ logger.info(f"Using cached JWT from config file (expires at {expires_at.isoformat()})")
+ else:
+ logger.info("Cached token from config file has expired or expiring soon, fetching new token")
+ except (ValueError, TypeError) as e:
+ logger.warning(f"Failed to parse token expiration time from config file: {e}, fetching new token")
+
+ # Priority 3: Fetch new token if none provided or all expired
+ if needs_new_token:
+ self._fetch_and_store_token()
+ token_source = "auth API"
+
+ # Initialize sub-clients
+ self.config_operations = self._init_config_operations_client()
+ self.config_setup = self._init_config_setup_client()
+ self.deployment_services = self._init_deployment_services_client()
+ self.device_settings = self._init_device_settings_client()
+ self.identity_services = self._init_identity_services_client()
+ self.network_services = self._init_network_services_client()
+ self.objects = self._init_objects_client()
+ self.security_services = self._init_security_services_client()
+
+ def _load_config_from_file(self) -> Dict[str, Any]:
+ """
+ Loads configuration from a JSON file.
+
+ Search order:
+ 1. SCM_CONFIG_FILE environment variable
+ 2. config/scm-config.json (project-local, matches scm-go layout)
+ """
+ # Explicit env var takes priority
+ env_path = os.environ.get("SCM_CONFIG_FILE")
+ if env_path:
+ path = Path(env_path)
+ if path.exists():
+ try:
+ with open(path, "r") as f:
+ return json.load(f)
+ except Exception as e:
+ logger.warning(f"Failed to load config file at {env_path}: {e}")
+ return {}
+ return {}
+
+ # Check project-local config/scm-config.json (matches scm-go)
+ local_path = Path("config/scm-config.json")
+ if local_path.exists():
+ try:
+ with open(local_path, "r") as f:
+ return json.load(f)
+ except Exception as e:
+ logger.warning(f"Failed to load config file at {local_path}: {e}")
+
+ return {}
+
+ def _fetch_and_store_token(self) -> None:
+ """
+ Fetches a new OAuth2 access token and stores metadata.
+ """
+ token_url = f"{self.auth_url}/oauth2/access_token"
+
+ # SCM requires tsg_id in the scope
+ scope = [f"tsg_id:{self.tsg_id}"] if self.tsg_id else None
+
+ logger.debug(f"Attempting Authentication to: {token_url}")
+ logger.debug(f"Client ID: {self.client_id[:4]}...{self.client_id[-4:] if len(self.client_id) > 4 else ''}")
+ logger.debug(f"Scope: {scope}")
+
+ # FIX: Tell oauthlib to relax scope validation.
+ os.environ["OAUTHLIB_RELAX_TOKEN_SCOPE"] = "1"
+
+ # 1. Create the standard OAuth2 Client
+ client = BackendApplicationClient(client_id=self.client_id, scope=scope)
+
+ # 2. Create the session with retry logic
+ oauth = OAuth2Session(client=client)
+
+ # Configure retry strategy with exponential backoff (matching scm-go)
+ # scm-go uses: 5 retries, exponential backoff (1s, 2s, 4s, 8s, 10s capped)
+ # See client.go lines 321-324
+ retry_strategy = Retry(
+ total=5, # Match scm-go's 5 retries (vs previous 3)
+ backoff_factor=1, # Exponential: 1s, 2s, 4s, 8s, 16s... (vs previous linear 0.3)
+ backoff_max=10, # Cap at 10 seconds (like scm-go's WithCappedDuration)
+ status_forcelist=[408, 429, 500, 502, 503, 504],
+ allowed_methods=["POST"],
+ )
+ adapter = HTTPAdapter(max_retries=retry_strategy)
+ oauth.mount("https://", adapter)
+ oauth.mount("http://", adapter)
+
+ # 3. Fetch the token with timeout
+ try:
+ token_response = oauth.fetch_token(
+ token_url=token_url,
+ client_id=self.client_id,
+ client_secret=self.client_secret,
+ verify=self.verify_ssl,
+ timeout=30
+ )
+
+ self._access_token = token_response["access_token"]
+
+ # Store token lifetime if available
+ if "expires_in" in token_response:
+ self._jwt_lifetime = int(token_response["expires_in"])
+ # Calculate expiration time with buffer (like scm-go: 60 second buffer)
+ self._token_expires_at = datetime.now(datetime.now().astimezone().tzinfo) + timedelta(
+ seconds=self._jwt_lifetime - self.TOKEN_EXPIRY_BUFFER
+ )
+ logger.debug(f"Token expires in {self._jwt_lifetime}s, will refresh at {self._token_expires_at.isoformat()}")
+
+ logger.info("Authentication successful.")
+
+ except Exception as e:
+ logger.error(f"Authentication Failed: {str(e)}")
+ raise ValueError(f"Failed to authenticate with SCM via OAuth2: {str(e)}")
+
+ def refresh_token(self) -> str:
+ """
+ Refresh the OAuth2 access token.
+
+ This method is thread-safe using a lock to prevent concurrent refresh attempts.
+ If multiple threads/requests call this simultaneously, only one will refresh
+ and the others will wait then return the newly refreshed token.
+
+ Before calling the auth API, checks if a valid token exists in config.json
+ (e.g., from automatic refresh via cron job) to avoid unnecessary API calls.
+
+ Returns:
+ str: The new access token
+
+ Raises:
+ ValueError: If token refresh fails
+ """
+ # Atomic refresh using lock (like scm-go's atomic counter pattern)
+ with self._refresh_lock:
+ # Double-check: another thread might have just refreshed
+ # (avoids unnecessary refresh if token was just updated)
+ if not self.token_expires_soon:
+ logger.debug("Token already refreshed by another thread, skipping refresh")
+ return self._access_token
+
+ # OPTIMIZATION: Before calling auth API, check if config file has a newer valid token
+ # This avoids unnecessary auth API calls when cron jobs or other processes
+ # have already refreshed the token in config.json
+ config_path = os.environ.get("SCM_CONFIG_FILE", os.path.expanduser("~/.scm/config.json"))
+ if Path(config_path).exists():
+ try:
+ config = self._load_config_from_file()
+ if config.get("jwt") and config.get("jwt_expires_at"):
+ # Check if this is a different token than what we have
+ if config.get("jwt") != self._access_token:
+ # Parse expiration time
+ cached_expires_at = datetime.fromisoformat(
+ config["jwt_expires_at"].replace('Z', '+00:00')
+ )
+ now = datetime.now(cached_expires_at.tzinfo)
+ time_until_expiry = (cached_expires_at - now).total_seconds()
+
+ # If cached token is still valid (not expiring within buffer), use it
+ if time_until_expiry > self.TOKEN_EXPIRY_BUFFER:
+ logger.info(
+ f"Found valid cached token in config file (expires in {int(time_until_expiry)}s), "
+ f"using it instead of fetching new token"
+ )
+ self._access_token = config["jwt"]
+ self._token_expires_at = cached_expires_at
+ self._jwt_lifetime = config.get("jwt_lifetime", 900)
+
+ # Update all sub-clients with the cached token
+ self._update_all_sub_clients()
+
+ return self._access_token
+ else:
+ logger.debug(
+ f"Cached token in config file expires soon ({int(time_until_expiry)}s), "
+ f"will fetch new token"
+ )
+ except Exception as e:
+ logger.debug(f"Could not load token from config file: {e}, will fetch new token")
+
+ logger.info("Refreshing access token...")
+ self._fetch_and_store_token()
+
+ # Update all sub-clients with the new token
+ self._update_all_sub_clients()
+
+ return self._access_token
+
+ def _update_all_sub_clients(self) -> None:
+ """
+ Update all sub-client configurations with the current access token.
+
+ This is called after token refresh to ensure all API clients use the new token.
+ """
+ if hasattr(self, 'config_operations') and hasattr(self.config_operations, 'api_client'):
+ self.config_operations.api_client.configuration.access_token = self._access_token
+ if hasattr(self, 'config_setup') and hasattr(self.config_setup, 'api_client'):
+ self.config_setup.api_client.configuration.access_token = self._access_token
+ if hasattr(self, 'deployment_services') and hasattr(self.deployment_services, 'api_client'):
+ self.deployment_services.api_client.configuration.access_token = self._access_token
+ if hasattr(self, 'device_settings') and hasattr(self.device_settings, 'api_client'):
+ self.device_settings.api_client.configuration.access_token = self._access_token
+ if hasattr(self, 'identity_services') and hasattr(self.identity_services, 'api_client'):
+ self.identity_services.api_client.configuration.access_token = self._access_token
+ if hasattr(self, 'network_services') and hasattr(self.network_services, 'api_client'):
+ self.network_services.api_client.configuration.access_token = self._access_token
+ if hasattr(self, 'objects') and hasattr(self.objects, 'api_client'):
+ self.objects.api_client.configuration.access_token = self._access_token
+ if hasattr(self, 'security_services') and hasattr(self.security_services, 'api_client'):
+ self.security_services.api_client.configuration.access_token = self._access_token
+
+ @property
+ def token_expires_soon(self) -> bool:
+ """
+ Check if the token will expire soon.
+
+ Returns:
+ bool: True if token is missing or expiring within TOKEN_EXPIRY_BUFFER seconds
+ """
+ if not self._access_token or not self._token_expires_at:
+ return True
+
+ # Check if current time is within TOKEN_EXPIRY_BUFFER seconds of expiry
+ buffer_time = timedelta(seconds=self.TOKEN_EXPIRY_BUFFER)
+ return datetime.now(self._token_expires_at.tzinfo) >= (self._token_expires_at - buffer_time)
+
+ @property
+ def access_token(self) -> Optional[str]:
+ """Get the current access token."""
+ return self._access_token
+ def _init_config_operations_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/operations/v1
+ config = ConfigOperationsConfiguration(
+ host=f"https://{self.host}/config/operations/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = ConfigOperationsApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ config_operations_api.api_client = client
+ return config_operations_api
+ def _init_config_setup_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/setup/v1
+ config = ConfigSetupConfiguration(
+ host=f"https://{self.host}/config/setup/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = ConfigSetupApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ config_setup_api.api_client = client
+ return config_setup_api
+ def _init_deployment_services_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/deployment/v1
+ config = DeploymentServicesConfiguration(
+ host=f"https://{self.host}/config/deployment/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = DeploymentServicesApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ deployment_services_api.api_client = client
+ return deployment_services_api
+ def _init_device_settings_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/device/v1
+ config = DeviceSettingsConfiguration(
+ host=f"https://{self.host}/config/device/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = DeviceSettingsApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ device_settings_api.api_client = client
+ return device_settings_api
+ def _init_identity_services_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/identity/v1
+ config = IdentityServicesConfiguration(
+ host=f"https://{self.host}/config/identity/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = IdentityServicesApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ identity_services_api.api_client = client
+ return identity_services_api
+ def _init_network_services_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/network/v1
+ config = NetworkServicesConfiguration(
+ host=f"https://{self.host}/config/network/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = NetworkServicesApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ network_services_api.api_client = client
+ return network_services_api
+ def _init_objects_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/objects/v1
+ config = ObjectsConfiguration(
+ host=f"https://{self.host}/config/objects/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = ObjectsApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ objects_api.api_client = client
+ return objects_api
+ def _init_security_services_client(self):
+ # Construct base URL by appending the service-specific path suffix
+ # Host: https://api.sase.paloaltonetworks.com
+ # Suffix: /config/security/v1
+ config = SecurityServicesConfiguration(
+ host=f"https://{self.host}/config/security/v1"
+ )
+ config.verify_ssl = self.verify_ssl
+ config.access_token = self._access_token
+
+ client = SecurityServicesApiClient(config)
+
+ # Wrap the rest client's request method to auto-refresh tokens
+ client.rest_client.request = _create_auto_refresh_wrapper(
+ self, client.rest_client.request
+ )
+
+ security_services_api.api_client = client
+ return security_services_api
diff --git a/scm/config_operations/__init__.py b/scm/config_operations/__init__.py
new file mode 100644
index 00000000..494efe4d
--- /dev/null
+++ b/scm/config_operations/__init__.py
@@ -0,0 +1,46 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from scm.config_operations.api.config_versions_api import ConfigVersionsApi
+from scm.config_operations.api.jobs_api import JobsApi
+
+# import ApiClient
+from scm.config_operations.api_response import ApiResponse
+from scm.config_operations.api_client import ApiClient
+from scm.config_operations.configuration import Configuration
+from scm.config_operations.exceptions import OpenApiException
+from scm.config_operations.exceptions import ApiTypeError
+from scm.config_operations.exceptions import ApiValueError
+from scm.config_operations.exceptions import ApiKeyError
+from scm.config_operations.exceptions import ApiAttributeError
+from scm.config_operations.exceptions import ApiException
+
+# import models into sdk package
+from scm.config_operations.models.config_version import ConfigVersion
+from scm.config_operations.models.config_versions_list_response import ConfigVersionsListResponse
+from scm.config_operations.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.config_operations.models.generic_error import GenericError
+from scm.config_operations.models.jobs import Jobs
+from scm.config_operations.models.jobs_list_response import JobsListResponse
+from scm.config_operations.models.jobs_response import JobsResponse
+from scm.config_operations.models.load_config import LoadConfig
+from scm.config_operations.models.push_candidate_config_versions_request import PushCandidateConfigVersionsRequest
+from scm.config_operations.models.running_config_versions_response import RunningConfigVersionsResponse
+from scm.config_operations.models.running_versions import RunningVersions
diff --git a/scm/config_operations/api/__init__.py b/scm/config_operations/api/__init__.py
new file mode 100644
index 00000000..69b9b3b4
--- /dev/null
+++ b/scm/config_operations/api/__init__.py
@@ -0,0 +1,6 @@
+# flake8: noqa
+
+# import apis into api package
+from scm.config_operations.api.config_versions_api import ConfigVersionsApi
+from scm.config_operations.api.jobs_api import JobsApi
+
diff --git a/scm/config_operations/api/config_versions_api.py b/scm/config_operations/api/config_versions_api.py
new file mode 100644
index 00000000..ef19387d
--- /dev/null
+++ b/scm/config_operations/api/config_versions_api.py
@@ -0,0 +1,1720 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.config_operations.models.config_version import ConfigVersion
+from scm.config_operations.models.config_versions_list_response import ConfigVersionsListResponse
+from scm.config_operations.models.load_config import LoadConfig
+from scm.config_operations.models.push_candidate_config_versions_request import PushCandidateConfigVersionsRequest
+from scm.config_operations.models.running_config_versions_response import RunningConfigVersionsResponse
+
+from scm.config_operations.api_client import ApiClient, RequestSerialized
+from scm.config_operations.api_response import ApiResponse
+from scm.config_operations.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ConfigVersionsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def delete_candidate_config_versions(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a candidate configuration
+
+ Delete a candidate configuration. Roll back to the running configuration.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_candidate_config_versions_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_candidate_config_versions_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a candidate configuration
+
+ Delete a candidate configuration. Roll back to the running configuration.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_candidate_config_versions_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_candidate_config_versions_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a candidate configuration
+
+ Delete a candidate configuration. Roll back to the running configuration.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_candidate_config_versions_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_candidate_config_versions_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/config-versions/candidate',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_config_versions_by_id(
+ self,
+ version: Annotated[StrictInt, Field(description="The configuration version number")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[ConfigVersion]:
+ """Get config by version
+
+ Get config by version.
+
+ :param version: The configuration version number (required)
+ :type version: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_config_versions_by_id_serialize(
+ version=version,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ConfigVersion]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_config_versions_by_id_with_http_info(
+ self,
+ version: Annotated[StrictInt, Field(description="The configuration version number")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[ConfigVersion]]:
+ """Get config by version
+
+ Get config by version.
+
+ :param version: The configuration version number (required)
+ :type version: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_config_versions_by_id_serialize(
+ version=version,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ConfigVersion]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_config_versions_by_id_without_preload_content(
+ self,
+ version: Annotated[StrictInt, Field(description="The configuration version number")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get config by version
+
+ Get config by version.
+
+ :param version: The configuration version number (required)
+ :type version: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_config_versions_by_id_serialize(
+ version=version,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ConfigVersion]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_config_versions_by_id_serialize(
+ self,
+ version,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if version is not None:
+ _path_params['version'] = version
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/config-versions/{version}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_running_config_versions(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RunningConfigVersionsResponse:
+ """Get running configuration versions
+
+ Get the running configuration versions on each folder.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_running_config_versions_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RunningConfigVersionsResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_running_config_versions_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RunningConfigVersionsResponse]:
+ """Get running configuration versions
+
+ Get the running configuration versions on each folder.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_running_config_versions_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RunningConfigVersionsResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_running_config_versions_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get running configuration versions
+
+ Get the running configuration versions on each folder.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_running_config_versions_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RunningConfigVersionsResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_running_config_versions_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/config-versions/running',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_config_versions(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ConfigVersionsListResponse:
+ """List configuration versions
+
+ Retrieve a list of configuration versions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_config_versions_serialize(
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigVersionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_config_versions_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ConfigVersionsListResponse]:
+ """List configuration versions
+
+ Retrieve a list of configuration versions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_config_versions_serialize(
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigVersionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_config_versions_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List configuration versions
+
+ Retrieve a list of configuration versions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_config_versions_serialize(
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigVersionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_config_versions_serialize(
+ self,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/config-versions',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def load_config_versions(
+ self,
+ load_config: Annotated[Optional[LoadConfig], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Load config version
+
+ Load a specific configuration version into the candidate configuration.
+
+ :param load_config: Created
+ :type load_config: LoadConfig
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_config_versions_serialize(
+ load_config=load_config,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def load_config_versions_with_http_info(
+ self,
+ load_config: Annotated[Optional[LoadConfig], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Load config version
+
+ Load a specific configuration version into the candidate configuration.
+
+ :param load_config: Created
+ :type load_config: LoadConfig
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_config_versions_serialize(
+ load_config=load_config,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def load_config_versions_without_preload_content(
+ self,
+ load_config: Annotated[Optional[LoadConfig], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Load config version
+
+ Load a specific configuration version into the candidate configuration.
+
+ :param load_config: Created
+ :type load_config: LoadConfig
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_config_versions_serialize(
+ load_config=load_config,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _load_config_versions_serialize(
+ self,
+ load_config,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if load_config is not None:
+ _body_params = load_config
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/config-versions:load',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def push_candidate_config_versions(
+ self,
+ push_candidate_config_versions_request: Annotated[Optional[PushCandidateConfigVersionsRequest], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Push the candidate configuration
+
+ Push the candidate configuration.
+
+ :param push_candidate_config_versions_request: Created
+ :type push_candidate_config_versions_request: PushCandidateConfigVersionsRequest
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._push_candidate_config_versions_serialize(
+ push_candidate_config_versions_request=push_candidate_config_versions_request,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def push_candidate_config_versions_with_http_info(
+ self,
+ push_candidate_config_versions_request: Annotated[Optional[PushCandidateConfigVersionsRequest], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Push the candidate configuration
+
+ Push the candidate configuration.
+
+ :param push_candidate_config_versions_request: Created
+ :type push_candidate_config_versions_request: PushCandidateConfigVersionsRequest
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._push_candidate_config_versions_serialize(
+ push_candidate_config_versions_request=push_candidate_config_versions_request,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def push_candidate_config_versions_without_preload_content(
+ self,
+ push_candidate_config_versions_request: Annotated[Optional[PushCandidateConfigVersionsRequest], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Push the candidate configuration
+
+ Push the candidate configuration.
+
+ :param push_candidate_config_versions_request: Created
+ :type push_candidate_config_versions_request: PushCandidateConfigVersionsRequest
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._push_candidate_config_versions_serialize(
+ push_candidate_config_versions_request=push_candidate_config_versions_request,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _push_candidate_config_versions_serialize(
+ self,
+ push_candidate_config_versions_request,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if push_candidate_config_versions_request is not None:
+ _body_params = push_candidate_config_versions_request
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/config-versions/candidate:push',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_operations/api/jobs_api.py b/scm/config_operations/api/jobs_api.py
new file mode 100644
index 00000000..946b9f6f
--- /dev/null
+++ b/scm/config_operations/api/jobs_api.py
@@ -0,0 +1,579 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing_extensions import Annotated
+from scm.config_operations.models.jobs_list_response import JobsListResponse
+from scm.config_operations.models.jobs_response import JobsResponse
+
+from scm.config_operations.api_client import ApiClient, RequestSerialized
+from scm.config_operations.api_response import ApiResponse
+from scm.config_operations.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class JobsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def get_jobs_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The ID of the job")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> JobsResponse:
+ """Get a job
+
+ Get an existing configuration job.
+
+ :param id: The ID of the job (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_jobs_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "JobsResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_jobs_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The ID of the job")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[JobsResponse]:
+ """Get a job
+
+ Get an existing configuration job.
+
+ :param id: The ID of the job (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_jobs_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "JobsResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_jobs_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The ID of the job")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a job
+
+ Get an existing configuration job.
+
+ :param id: The ID of the job (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_jobs_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "JobsResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_jobs_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/jobs/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_jobs(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> JobsListResponse:
+ """List jobs
+
+ Retrieve a list of configuration jobs.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_jobs_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "JobsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_jobs_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[JobsListResponse]:
+ """List jobs
+
+ Retrieve a list of configuration jobs.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_jobs_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "JobsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_jobs_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List jobs
+
+ Retrieve a list of configuration jobs.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_jobs_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "JobsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_jobs_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/jobs',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_operations/api_client.py b/scm/config_operations/api_client.py
new file mode 100644
index 00000000..fdd1fd8f
--- /dev/null
+++ b/scm/config_operations/api_client.py
@@ -0,0 +1,798 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import datetime
+from dateutil.parser import parse
+from enum import Enum
+import decimal
+import json
+import mimetypes
+import os
+import re
+import tempfile
+
+from urllib.parse import quote
+from typing import Tuple, Optional, List, Dict, Union
+from pydantic import SecretStr
+
+from scm.config_operations.configuration import Configuration
+from scm.config_operations.api_response import ApiResponse, T as ApiResponseT
+import scm.config_operations.models
+from scm.config_operations import rest
+from scm.config_operations.exceptions import (
+ ApiValueError,
+ ApiException,
+ BadRequestException,
+ UnauthorizedException,
+ ForbiddenException,
+ NotFoundException,
+ ServiceException
+)
+
+RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]
+
+class ApiClient:
+ """Generic API client for OpenAPI client library builds.
+
+ OpenAPI generic API client. This client handles the client-
+ server communication, and is invariant across implementations. Specifics of
+ the methods and models for each application are generated from the OpenAPI
+ templates.
+
+ :param configuration: .Configuration object for this client
+ :param header_name: a header to pass when making calls to the API.
+ :param header_value: a header value to pass when making calls to
+ the API.
+ :param cookie: a cookie to include in the header when making calls
+ to the API
+ """
+
+ PRIMITIVE_TYPES = (float, bool, bytes, str, int)
+ NATIVE_TYPES_MAPPING = {
+ 'int': int,
+ 'long': int, # TODO remove as only py3 is supported?
+ 'float': float,
+ 'str': str,
+ 'bool': bool,
+ 'date': datetime.date,
+ 'datetime': datetime.datetime,
+ 'decimal': decimal.Decimal,
+ 'object': object,
+ }
+ _pool = None
+
+ def __init__(
+ self,
+ configuration=None,
+ header_name=None,
+ header_value=None,
+ cookie=None
+ ) -> None:
+ # use default configuration if none is provided
+ if configuration is None:
+ configuration = Configuration.get_default()
+ self.configuration = configuration
+
+ self.rest_client = rest.RESTClientObject(configuration)
+ self.default_headers = {}
+ if header_name is not None:
+ self.default_headers[header_name] = header_value
+ self.cookie = cookie
+ # Set default User-Agent.
+ self.user_agent = 'OpenAPI-Generator/1.0.0/python'
+ self.client_side_validation = configuration.client_side_validation
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ pass
+
+ @property
+ def user_agent(self):
+ """User agent for this API client"""
+ return self.default_headers['User-Agent']
+
+ @user_agent.setter
+ def user_agent(self, value):
+ self.default_headers['User-Agent'] = value
+
+ def set_default_header(self, header_name, header_value):
+ self.default_headers[header_name] = header_value
+
+
+ _default = None
+
+ @classmethod
+ def get_default(cls):
+ """Return new instance of ApiClient.
+
+ This method returns newly created, based on default constructor,
+ object of ApiClient class or returns a copy of default
+ ApiClient.
+
+ :return: The ApiClient object.
+ """
+ if cls._default is None:
+ cls._default = ApiClient()
+ return cls._default
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of ApiClient.
+
+ It stores default ApiClient.
+
+ :param default: object of ApiClient.
+ """
+ cls._default = default
+
+ def param_serialize(
+ self,
+ method,
+ resource_path,
+ path_params=None,
+ query_params=None,
+ header_params=None,
+ body=None,
+ post_params=None,
+ files=None, auth_settings=None,
+ collection_formats=None,
+ _host=None,
+ _request_auth=None
+ ) -> RequestSerialized:
+
+ """Builds the HTTP request params needed by the request.
+ :param method: Method to call.
+ :param resource_path: Path to method endpoint.
+ :param path_params: Path parameters in the url.
+ :param query_params: Query parameters in the url.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param auth_settings list: Auth Settings names for the request.
+ :param files dict: key -> filename, value -> filepath,
+ for `multipart/form-data`.
+ :param collection_formats: dict of collection formats for path, query,
+ header, and post parameters.
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the authentication
+ in the spec for a single request.
+ :return: tuple of form (path, http_method, query_params, header_params,
+ body, post_params, files)
+ """
+
+ config = self.configuration
+
+ # header parameters
+ header_params = header_params or {}
+ header_params.update(self.default_headers)
+ if self.cookie:
+ header_params['Cookie'] = self.cookie
+ if header_params:
+ header_params = self.sanitize_for_serialization(header_params)
+ header_params = dict(
+ self.parameters_to_tuples(header_params,collection_formats)
+ )
+
+ # path parameters
+ if path_params:
+ path_params = self.sanitize_for_serialization(path_params)
+ path_params = self.parameters_to_tuples(
+ path_params,
+ collection_formats
+ )
+ for k, v in path_params:
+ # specified safe chars, encode everything
+ resource_path = resource_path.replace(
+ '{%s}' % k,
+ quote(str(v), safe=config.safe_chars_for_path_param)
+ )
+
+ # post parameters
+ if post_params or files:
+ post_params = post_params if post_params else []
+ post_params = self.sanitize_for_serialization(post_params)
+ post_params = self.parameters_to_tuples(
+ post_params,
+ collection_formats
+ )
+ if files:
+ post_params.extend(self.files_parameters(files))
+
+ # auth setting
+ self.update_params_for_auth(
+ header_params,
+ query_params,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=_request_auth
+ )
+
+ # body
+ if body:
+ body = self.sanitize_for_serialization(body)
+
+ # request url
+ if _host is None or self.configuration.ignore_operation_servers:
+ url = self.configuration.host + resource_path
+ else:
+ # use server/host defined in path or operation instead
+ url = _host + resource_path
+
+ # query parameters
+ if query_params:
+ query_params = self.sanitize_for_serialization(query_params)
+ url_query = self.parameters_to_url_query(
+ query_params,
+ collection_formats
+ )
+ url += "?" + url_query
+
+ return method, url, header_params, body, post_params
+
+
+ def call_api(
+ self,
+ method,
+ url,
+ header_params=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ) -> rest.RESTResponse:
+ """Makes the HTTP request (synchronous)
+ :param method: Method to call.
+ :param url: Path to method endpoint.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param _request_timeout: timeout setting for this request.
+ :return: RESTResponse
+ """
+
+ try:
+ # perform request and return response
+ response_data = self.rest_client.request(
+ method, url,
+ headers=header_params,
+ body=body, post_params=post_params,
+ _request_timeout=_request_timeout
+ )
+
+ except ApiException as e:
+ raise e
+
+ return response_data
+
+ def response_deserialize(
+ self,
+ response_data: rest.RESTResponse,
+ response_types_map: Optional[Dict[str, ApiResponseT]]=None
+ ) -> ApiResponse[ApiResponseT]:
+ """Deserializes response into an object.
+ :param response_data: RESTResponse object to be deserialized.
+ :param response_types_map: dict of response types.
+ :return: ApiResponse
+ """
+
+ msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
+ assert response_data.data is not None, msg
+
+ response_type = response_types_map.get(str(response_data.status), None)
+ if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
+ # if not found, look for '1XX', '2XX', etc.
+ response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
+
+ # deserialize response data
+ response_text = None
+ return_data = None
+ try:
+ if response_type == "bytearray":
+ return_data = response_data.data
+ elif response_type == "file":
+ return_data = self.__deserialize_file(response_data)
+ elif response_type is not None:
+ match = None
+ content_type = response_data.getheader('content-type')
+ if content_type is not None:
+ match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
+ encoding = match.group(1) if match else "utf-8"
+ response_text = response_data.data.decode(encoding)
+ return_data = self.deserialize(response_text, response_type, content_type)
+ finally:
+ if not 200 <= response_data.status <= 299:
+ raise ApiException.from_response(
+ http_resp=response_data,
+ body=response_text,
+ data=return_data,
+ )
+
+ return ApiResponse(
+ status_code = response_data.status,
+ data = return_data,
+ headers = response_data.getheaders(),
+ raw_data = response_data.data
+ )
+
+ def sanitize_for_serialization(self, obj):
+ """Builds a JSON POST object.
+
+ If obj is None, return None.
+ If obj is SecretStr, return obj.get_secret_value()
+ If obj is str, int, long, float, bool, return directly.
+ If obj is datetime.datetime, datetime.date
+ convert to string in iso8601 format.
+ If obj is decimal.Decimal return string representation.
+ If obj is list, sanitize each element in the list.
+ If obj is dict, return the dict.
+ If obj is OpenAPI model, return the properties dict.
+
+ :param obj: The data to serialize.
+ :return: The serialized form of data.
+ """
+ if obj is None:
+ return None
+ elif isinstance(obj, Enum):
+ return obj.value
+ elif isinstance(obj, SecretStr):
+ return obj.get_secret_value()
+ elif isinstance(obj, self.PRIMITIVE_TYPES):
+ return obj
+ elif isinstance(obj, list):
+ return [
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ ]
+ elif isinstance(obj, tuple):
+ return tuple(
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ )
+ elif isinstance(obj, (datetime.datetime, datetime.date)):
+ return obj.isoformat()
+ elif isinstance(obj, decimal.Decimal):
+ return str(obj)
+
+ elif isinstance(obj, dict):
+ obj_dict = obj
+ else:
+ # Convert model obj to dict except
+ # attributes `openapi_types`, `attribute_map`
+ # and attributes which value is not None.
+ # Convert attribute name to json key in
+ # model definition for request.
+ if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
+ obj_dict = obj.to_dict()
+ else:
+ obj_dict = obj.__dict__
+
+ return {
+ key: self.sanitize_for_serialization(val)
+ for key, val in obj_dict.items()
+ }
+
+ def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]):
+ """Deserializes response into an object.
+
+ :param response: RESTResponse object to be deserialized.
+ :param response_type: class literal for
+ deserialized object, or string of class name.
+ :param content_type: content type of response.
+
+ :return: deserialized object.
+ """
+
+ # fetch data from response object
+ if content_type is None:
+ try:
+ data = json.loads(response_text)
+ except ValueError:
+ data = response_text
+ elif re.match(r'^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)', content_type, re.IGNORECASE):
+ if response_text == "":
+ data = ""
+ else:
+ data = json.loads(response_text)
+ elif re.match(r'^text\/[a-z.+-]+\s*(;|$)', content_type, re.IGNORECASE):
+ data = response_text
+ else:
+ raise ApiException(
+ status=0,
+ reason="Unsupported content type: {0}".format(content_type)
+ )
+
+ return self.__deserialize(data, response_type)
+
+ def __deserialize(self, data, klass):
+ """Deserializes dict, list, str into an object.
+
+ :param data: dict, list or str.
+ :param klass: class literal, or string of class name.
+
+ :return: object.
+ """
+ if data is None:
+ return None
+
+ if isinstance(klass, str):
+ if klass.startswith('List['):
+ m = re.match(r'List\[(.*)]', klass)
+ assert m is not None, "Malformed List type definition"
+ sub_kls = m.group(1)
+ return [self.__deserialize(sub_data, sub_kls)
+ for sub_data in data]
+
+ if klass.startswith('Dict['):
+ m = re.match(r'Dict\[([^,]*), (.*)]', klass)
+ assert m is not None, "Malformed Dict type definition"
+ sub_kls = m.group(2)
+ return {k: self.__deserialize(v, sub_kls)
+ for k, v in data.items()}
+
+ # convert str to class
+ if klass in self.NATIVE_TYPES_MAPPING:
+ klass = self.NATIVE_TYPES_MAPPING[klass]
+ else:
+ klass = getattr(scm.config_operations.models, klass)
+
+ if klass in self.PRIMITIVE_TYPES:
+ return self.__deserialize_primitive(data, klass)
+ elif klass == object:
+ return self.__deserialize_object(data)
+ elif klass == datetime.date:
+ return self.__deserialize_date(data)
+ elif klass == datetime.datetime:
+ return self.__deserialize_datetime(data)
+ elif klass == decimal.Decimal:
+ return decimal.Decimal(data)
+ elif issubclass(klass, Enum):
+ return self.__deserialize_enum(data, klass)
+ else:
+ return self.__deserialize_model(data, klass)
+
+ def parameters_to_tuples(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: Parameters as list of tuples, collections formatted
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, value) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(str(value) for value in v)))
+ else:
+ new_params.append((k, v))
+ return new_params
+
+ def parameters_to_url_query(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: URL query string (e.g. a=Hello%20World&b=123)
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if isinstance(v, bool):
+ v = str(v).lower()
+ if isinstance(v, (int, float)):
+ v = str(v)
+ if isinstance(v, dict):
+ v = json.dumps(v)
+
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, str(value)) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(quote(str(value)) for value in v))
+ )
+ else:
+ new_params.append((k, quote(str(v))))
+
+ return "&".join(["=".join(map(str, item)) for item in new_params])
+
+ def files_parameters(
+ self,
+ files: Dict[str, Union[str, bytes, List[str], List[bytes], Tuple[str, bytes]]],
+ ):
+ """Builds form parameters.
+
+ :param files: File parameters.
+ :return: Form parameters with files.
+ """
+ params = []
+ for k, v in files.items():
+ if isinstance(v, str):
+ with open(v, 'rb') as f:
+ filename = os.path.basename(f.name)
+ filedata = f.read()
+ elif isinstance(v, bytes):
+ filename = k
+ filedata = v
+ elif isinstance(v, tuple):
+ filename, filedata = v
+ elif isinstance(v, list):
+ for file_param in v:
+ params.extend(self.files_parameters({k: file_param}))
+ continue
+ else:
+ raise ValueError("Unsupported file value")
+ mimetype = (
+ mimetypes.guess_type(filename)[0]
+ or 'application/octet-stream'
+ )
+ params.append(
+ tuple([k, tuple([filename, filedata, mimetype])])
+ )
+ return params
+
+ def select_header_accept(self, accepts: List[str]) -> Optional[str]:
+ """Returns `Accept` based on an array of accepts provided.
+
+ :param accepts: List of headers.
+ :return: Accept (e.g. application/json).
+ """
+ if not accepts:
+ return None
+
+ for accept in accepts:
+ if re.search('json', accept, re.IGNORECASE):
+ return accept
+
+ return accepts[0]
+
+ def select_header_content_type(self, content_types):
+ """Returns `Content-Type` based on an array of content_types provided.
+
+ :param content_types: List of content-types.
+ :return: Content-Type (e.g. application/json).
+ """
+ if not content_types:
+ return None
+
+ for content_type in content_types:
+ if re.search('json', content_type, re.IGNORECASE):
+ return content_type
+
+ return content_types[0]
+
+ def update_params_for_auth(
+ self,
+ headers,
+ queries,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=None
+ ) -> None:
+ """Updates header and query params based on authentication setting.
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :param auth_settings: Authentication setting identifiers list.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param request_auth: if set, the provided settings will
+ override the token in the configuration.
+ """
+ if not auth_settings:
+ return
+
+ if request_auth:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ request_auth
+ )
+ else:
+ for auth in auth_settings:
+ auth_setting = self.configuration.auth_settings().get(auth)
+ if auth_setting:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ )
+
+ def _apply_auth_params(
+ self,
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ ) -> None:
+ """Updates the request parameters based on a single auth_setting
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param auth_setting: auth settings for the endpoint
+ """
+ if auth_setting['in'] == 'cookie':
+ headers['Cookie'] = auth_setting['value']
+ elif auth_setting['in'] == 'header':
+ if auth_setting['type'] != 'http-signature':
+ headers[auth_setting['key']] = auth_setting['value']
+ elif auth_setting['in'] == 'query':
+ queries.append((auth_setting['key'], auth_setting['value']))
+ else:
+ raise ApiValueError(
+ 'Authentication token must be in `query` or `header`'
+ )
+
+ def __deserialize_file(self, response):
+ """Deserializes body to file
+
+ Saves response body into a file in a temporary folder,
+ using the filename from the `Content-Disposition` header if provided.
+
+ handle file downloading
+ save response body into a tmp file and return the instance
+
+ :param response: RESTResponse.
+ :return: file path.
+ """
+ fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
+ os.close(fd)
+ os.remove(path)
+
+ content_disposition = response.getheader("Content-Disposition")
+ if content_disposition:
+ m = re.search(
+ r'filename=[\'"]?([^\'"\s]+)[\'"]?',
+ content_disposition
+ )
+ assert m is not None, "Unexpected 'content-disposition' header value"
+ filename = m.group(1)
+ path = os.path.join(os.path.dirname(path), filename)
+
+ with open(path, "wb") as f:
+ f.write(response.data)
+
+ return path
+
+ def __deserialize_primitive(self, data, klass):
+ """Deserializes string to primitive type.
+
+ :param data: str.
+ :param klass: class literal.
+
+ :return: int, long, float, str, bool.
+ """
+ try:
+ return klass(data)
+ except UnicodeEncodeError:
+ return str(data)
+ except TypeError:
+ return data
+
+ def __deserialize_object(self, value):
+ """Return an original value.
+
+ :return: object.
+ """
+ return value
+
+ def __deserialize_date(self, string):
+ """Deserializes string to date.
+
+ :param string: str.
+ :return: date.
+ """
+ try:
+ return parse(string).date()
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason="Failed to parse `{0}` as date object".format(string)
+ )
+
+ def __deserialize_datetime(self, string):
+ """Deserializes string to datetime.
+
+ The string should be in iso8601 datetime format.
+
+ :param string: str.
+ :return: datetime.
+ """
+ try:
+ return parse(string)
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as datetime object"
+ .format(string)
+ )
+ )
+
+ def __deserialize_enum(self, data, klass):
+ """Deserializes primitive type to enum.
+
+ :param data: primitive type.
+ :param klass: class literal.
+ :return: enum value.
+ """
+ try:
+ return klass(data)
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as `{1}`"
+ .format(data, klass)
+ )
+ )
+
+ def __deserialize_model(self, data, klass):
+ """Deserializes list or dict to model.
+
+ :param data: dict, list.
+ :param klass: class literal.
+ :return: model object.
+ """
+
+ return klass.from_dict(data)
diff --git a/scm/config_operations/api_response.py b/scm/config_operations/api_response.py
new file mode 100644
index 00000000..9bc7c11f
--- /dev/null
+++ b/scm/config_operations/api_response.py
@@ -0,0 +1,21 @@
+"""API response object."""
+
+from __future__ import annotations
+from typing import Optional, Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+ """
+ API response object
+ """
+
+ status_code: StrictInt = Field(description="HTTP status code")
+ headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
+ data: T = Field(description="Deserialized data given the data type")
+ raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
+
+ model_config = {
+ "arbitrary_types_allowed": True
+ }
diff --git a/scm/config_operations/configuration.py b/scm/config_operations/configuration.py
new file mode 100644
index 00000000..6f922126
--- /dev/null
+++ b/scm/config_operations/configuration.py
@@ -0,0 +1,471 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import copy
+import logging
+from logging import FileHandler
+import multiprocessing
+import sys
+from typing import Optional
+import urllib3
+
+import http.client as httplib
+
+JSON_SCHEMA_VALIDATION_KEYWORDS = {
+ 'multipleOf', 'maximum', 'exclusiveMaximum',
+ 'minimum', 'exclusiveMinimum', 'maxLength',
+ 'minLength', 'pattern', 'maxItems', 'minItems'
+}
+
+class Configuration:
+ """This class contains various settings of the API client.
+
+ :param host: Base url.
+ :param ignore_operation_servers
+ Boolean to ignore operation servers for the API client.
+ Config will use `host` as the base url regardless of the operation servers.
+ :param api_key: Dict to store API key(s).
+ Each entry in the dict specifies an API key.
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is the API key secret.
+ :param api_key_prefix: Dict to store API prefix (e.g. Bearer).
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is an API key prefix when generating the auth data.
+ :param username: Username for HTTP basic authentication.
+ :param password: Password for HTTP basic authentication.
+ :param access_token: Access token.
+ :param server_index: Index to servers configuration.
+ :param server_variables: Mapping with string values to replace variables in
+ templated server configuration. The validation of enums is performed for
+ variables with defined enum values before.
+ :param server_operation_index: Mapping from operation ID to an index to server
+ configuration.
+ :param server_operation_variables: Mapping from operation ID to a mapping with
+ string values to replace variables in templated server configuration.
+ The validation of enums is performed for variables with defined enum
+ values before.
+ :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
+ in PEM format.
+ :param retries: Number of retries for API requests.
+
+ :Example:
+ """
+
+ _default = None
+
+ def __init__(self, host=None,
+ api_key=None, api_key_prefix=None,
+ username=None, password=None,
+ access_token=None,
+ server_index=None, server_variables=None,
+ server_operation_index=None, server_operation_variables=None,
+ ignore_operation_servers=False,
+ ssl_ca_cert=None,
+ retries=None,
+ *,
+ debug: Optional[bool] = None
+ ) -> None:
+ """Constructor
+ """
+ self._base_path = "https://api.strata.paloaltonetworks.com/config/operations/v1" if host is None else host
+ """Default Base url
+ """
+ self.server_index = 0 if server_index is None and host is None else server_index
+ self.server_operation_index = server_operation_index or {}
+ """Default server index
+ """
+ self.server_variables = server_variables or {}
+ self.server_operation_variables = server_operation_variables or {}
+ """Default server variables
+ """
+ self.ignore_operation_servers = ignore_operation_servers
+ """Ignore operation servers
+ """
+ self.temp_folder_path = None
+ """Temp file folder for downloading files
+ """
+ # Authentication Settings
+ self.api_key = {}
+ if api_key:
+ self.api_key = api_key
+ """dict to store API key(s)
+ """
+ self.api_key_prefix = {}
+ if api_key_prefix:
+ self.api_key_prefix = api_key_prefix
+ """dict to store API prefix (e.g. Bearer)
+ """
+ self.refresh_api_key_hook = None
+ """function hook to refresh API key if expired
+ """
+ self.username = username
+ """Username for HTTP basic authentication
+ """
+ self.password = password
+ """Password for HTTP basic authentication
+ """
+ self.access_token = access_token
+ """Access token
+ """
+ self.logger = {}
+ """Logging Settings
+ """
+ self.logger["package_logger"] = logging.getLogger("scm.config_operations")
+ self.logger["urllib3_logger"] = logging.getLogger("urllib3")
+ self.logger_format = '%(asctime)s %(levelname)s %(message)s'
+ """Log format
+ """
+ self.logger_stream_handler = None
+ """Log stream handler
+ """
+ self.logger_file_handler: Optional[FileHandler] = None
+ """Log file handler
+ """
+ self.logger_file = None
+ """Debug file location
+ """
+ if debug is not None:
+ self.debug = debug
+ else:
+ self.__debug = False
+ """Debug switch
+ """
+
+ self.verify_ssl = True
+ """SSL/TLS verification
+ Set this to false to skip verifying SSL certificate when calling API
+ from https server.
+ """
+ self.ssl_ca_cert = ssl_ca_cert
+ """Set this to customize the certificate file to verify the peer.
+ """
+ self.cert_file = None
+ """client certificate file
+ """
+ self.key_file = None
+ """client key file
+ """
+ self.assert_hostname = None
+ """Set this to True/False to enable/disable SSL hostname verification.
+ """
+ self.tls_server_name = None
+ """SSL/TLS Server Name Indication (SNI)
+ Set this to the SNI value expected by the server.
+ """
+
+ self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
+ """urllib3 connection pool's maximum number of connections saved
+ per pool. urllib3 uses 1 connection as default value, but this is
+ not the best value when you are making a lot of possibly parallel
+ requests to the same host, which is often the case here.
+ cpu_count * 5 is used as default value to increase performance.
+ """
+
+ self.proxy: Optional[str] = None
+ """Proxy URL
+ """
+ self.proxy_headers = None
+ """Proxy headers
+ """
+ self.safe_chars_for_path_param = ''
+ """Safe chars for path_param
+ """
+ self.retries = retries
+ """Adding retries to override urllib3 default value 3
+ """
+ # Enable client side validation
+ self.client_side_validation = True
+
+ self.socket_options = None
+ """Options to pass down to the underlying urllib3 socket
+ """
+
+ self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z"
+ """datetime format
+ """
+
+ self.date_format = "%Y-%m-%d"
+ """date format
+ """
+
+ def __deepcopy__(self, memo):
+ cls = self.__class__
+ result = cls.__new__(cls)
+ memo[id(self)] = result
+ for k, v in self.__dict__.items():
+ if k not in ('logger', 'logger_file_handler'):
+ setattr(result, k, copy.deepcopy(v, memo))
+ # shallow copy of loggers
+ result.logger = copy.copy(self.logger)
+ # use setters to configure loggers
+ result.logger_file = self.logger_file
+ result.debug = self.debug
+ return result
+
+ def __setattr__(self, name, value):
+ object.__setattr__(self, name, value)
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of configuration.
+
+ It stores default configuration, which can be
+ returned by get_default_copy method.
+
+ :param default: object of Configuration
+ """
+ cls._default = default
+
+ @classmethod
+ def get_default_copy(cls):
+ """Deprecated. Please use `get_default` instead.
+
+ Deprecated. Please use `get_default` instead.
+
+ :return: The configuration object.
+ """
+ return cls.get_default()
+
+ @classmethod
+ def get_default(cls):
+ """Return the default configuration.
+
+ This method returns newly created, based on default constructor,
+ object of Configuration class or returns a copy of default
+ configuration.
+
+ :return: The configuration object.
+ """
+ if cls._default is None:
+ cls._default = Configuration()
+ return cls._default
+
+ @property
+ def logger_file(self):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ return self.__logger_file
+
+ @logger_file.setter
+ def logger_file(self, value):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ self.__logger_file = value
+ if self.__logger_file:
+ # If set logging file,
+ # then add file handler and remove stream handler.
+ self.logger_file_handler = logging.FileHandler(self.__logger_file)
+ self.logger_file_handler.setFormatter(self.logger_formatter)
+ for _, logger in self.logger.items():
+ logger.addHandler(self.logger_file_handler)
+
+ @property
+ def debug(self):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ return self.__debug
+
+ @debug.setter
+ def debug(self, value):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ self.__debug = value
+ if self.__debug:
+ # if debug status is True, turn on debug logging
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.DEBUG)
+ # turn on httplib debug
+ httplib.HTTPConnection.debuglevel = 1
+ else:
+ # if debug status is False, turn off debug logging,
+ # setting log level to default `logging.WARNING`
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.WARNING)
+ # turn off httplib debug
+ httplib.HTTPConnection.debuglevel = 0
+
+ @property
+ def logger_format(self):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ return self.__logger_format
+
+ @logger_format.setter
+ def logger_format(self, value):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ self.__logger_format = value
+ self.logger_formatter = logging.Formatter(self.__logger_format)
+
+ def get_api_key_with_prefix(self, identifier, alias=None):
+ """Gets API key (with prefix if set).
+
+ :param identifier: The identifier of apiKey.
+ :param alias: The alternative identifier of apiKey.
+ :return: The token for api key authentication.
+ """
+ if self.refresh_api_key_hook is not None:
+ self.refresh_api_key_hook(self)
+ key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
+ if key:
+ prefix = self.api_key_prefix.get(identifier)
+ if prefix:
+ return "%s %s" % (prefix, key)
+ else:
+ return key
+
+ def get_basic_auth_token(self):
+ """Gets HTTP basic authentication header (string).
+
+ :return: The token for basic HTTP authentication.
+ """
+ username = ""
+ if self.username is not None:
+ username = self.username
+ password = ""
+ if self.password is not None:
+ password = self.password
+ return urllib3.util.make_headers(
+ basic_auth=username + ':' + password
+ ).get('authorization')
+
+ def auth_settings(self):
+ """Gets Auth Settings dict for api client.
+
+ :return: The Auth Settings information dict.
+ """
+ auth = {}
+ if self.access_token is not None:
+ auth['scmOAuth'] = {
+ 'type': 'oauth2',
+ 'in': 'header',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ if self.access_token is not None:
+ auth['scmToken'] = {
+ 'type': 'bearer',
+ 'in': 'header',
+ 'format': 'JWT',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ return auth
+
+ def to_debug_report(self):
+ """Gets the essential information for debugging.
+
+ :return: The report for debugging.
+ """
+ return "Python SDK Debug Report:\n"\
+ "OS: {env}\n"\
+ "Python Version: {pyversion}\n"\
+ "Version of the API: 2.0.0\n"\
+ "SDK Package Version: 1.0.0".\
+ format(env=sys.platform, pyversion=sys.version)
+
+ def get_host_settings(self):
+ """Gets an array of host settings
+
+ :return: An array of host settings
+ """
+ return [
+ {
+ 'url': "https://api.strata.paloaltonetworks.com/config/operations/v1",
+ 'description': "Current",
+ },
+ {
+ 'url': "https://api.sase.paloaltonetworks.com/sse/config/v1",
+ 'description': "Legacy",
+ }
+ ]
+
+ def get_host_from_settings(self, index, variables=None, servers=None):
+ """Gets host URL based on the index and variables
+ :param index: array index of the host settings
+ :param variables: hash of variable and the corresponding value
+ :param servers: an array of host settings or None
+ :return: URL based on host settings
+ """
+ if index is None:
+ return self._base_path
+
+ variables = {} if variables is None else variables
+ servers = self.get_host_settings() if servers is None else servers
+
+ try:
+ server = servers[index]
+ except IndexError:
+ raise ValueError(
+ "Invalid index {0} when selecting the host settings. "
+ "Must be less than {1}".format(index, len(servers)))
+
+ url = server['url']
+
+ # go through variables and replace placeholders
+ for variable_name, variable in server.get('variables', {}).items():
+ used_value = variables.get(
+ variable_name, variable['default_value'])
+
+ if 'enum_values' in variable \
+ and used_value not in variable['enum_values']:
+ raise ValueError(
+ "The variable `{0}` in the host URL has invalid value "
+ "{1}. Must be {2}.".format(
+ variable_name, variables[variable_name],
+ variable['enum_values']))
+
+ url = url.replace("{" + variable_name + "}", used_value)
+
+ return url
+
+ @property
+ def host(self):
+ """Return generated host."""
+ return self.get_host_from_settings(self.server_index, variables=self.server_variables)
+
+ @host.setter
+ def host(self, value):
+ """Fix base path."""
+ self._base_path = value
+ self.server_index = None
diff --git a/scm/config_operations/docs/ConfigVersion.md b/scm/config_operations/docs/ConfigVersion.md
new file mode 100644
index 00000000..508b252a
--- /dev/null
+++ b/scm/config_operations/docs/ConfigVersion.md
@@ -0,0 +1,42 @@
+# ConfigVersion
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**admin** | **str** | The administrator or service account that pushed this configuration version |
+**created** | **float** | |
+**var_date** | **datetime** | |
+**deleted** | **float** | |
+**description** | **str** | |
+**edited_by** | **str** | | [optional]
+**id** | **int** | The configuration version |
+**impacted_devices** | **str** | | [optional]
+**ngfw_scope** | **str** | A comma separated list of firewall serial numbers | [optional]
+**scope** | **str** | |
+**swg_config** | **str** | | [optional]
+**types** | **str** | | [optional]
+**updated** | **float** | |
+**version** | **str** | The configuration version name |
+
+## Example
+
+```python
+from scm.config_operations.models.config_version import ConfigVersion
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ConfigVersion from a JSON string
+config_version_instance = ConfigVersion.from_json(json)
+# print the JSON string representation of the object
+print(ConfigVersion.to_json())
+
+# convert the object into a dict
+config_version_dict = config_version_instance.to_dict()
+# create an instance of ConfigVersion from a dict
+config_version_from_dict = ConfigVersion.from_dict(config_version_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/ConfigVersionsApi.md b/scm/config_operations/docs/ConfigVersionsApi.md
new file mode 100644
index 00000000..1768171b
--- /dev/null
+++ b/scm/config_operations/docs/ConfigVersionsApi.md
@@ -0,0 +1,500 @@
+# scm.config_operations.ConfigVersionsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/operations/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**delete_candidate_config_versions**](ConfigVersionsApi.md#delete_candidate_config_versions) | **DELETE** /config-versions/candidate | Delete a candidate configuration
+[**get_config_versions_by_id**](ConfigVersionsApi.md#get_config_versions_by_id) | **GET** /config-versions/{version} | Get config by version
+[**get_running_config_versions**](ConfigVersionsApi.md#get_running_config_versions) | **GET** /config-versions/running | Get running configuration versions
+[**list_config_versions**](ConfigVersionsApi.md#list_config_versions) | **GET** /config-versions | List configuration versions
+[**load_config_versions**](ConfigVersionsApi.md#load_config_versions) | **POST** /config-versions:load | Load config version
+[**push_candidate_config_versions**](ConfigVersionsApi.md#push_candidate_config_versions) | **POST** /config-versions/candidate:push | Push the candidate configuration
+
+
+# **delete_candidate_config_versions**
+> delete_candidate_config_versions()
+
+Delete a candidate configuration
+
+Delete a candidate configuration. Roll back to the running configuration.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.ConfigVersionsApi(api_client)
+
+ try:
+ # Delete a candidate configuration
+ api_instance.delete_candidate_config_versions()
+ except Exception as e:
+ print("Exception when calling ConfigVersionsApi->delete_candidate_config_versions: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_config_versions_by_id**
+> List[ConfigVersion] get_config_versions_by_id(version)
+
+Get config by version
+
+Get config by version.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.models.config_version import ConfigVersion
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.ConfigVersionsApi(api_client)
+ version = 56 # int | The configuration version number
+
+ try:
+ # Get config by version
+ api_response = api_instance.get_config_versions_by_id(version)
+ print("The response of ConfigVersionsApi->get_config_versions_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ConfigVersionsApi->get_config_versions_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **version** | **int**| The configuration version number |
+
+### Return type
+
+[**List[ConfigVersion]**](ConfigVersion.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_running_config_versions**
+> RunningConfigVersionsResponse get_running_config_versions()
+
+Get running configuration versions
+
+Get the running configuration versions on each folder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.models.running_config_versions_response import RunningConfigVersionsResponse
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.ConfigVersionsApi(api_client)
+
+ try:
+ # Get running configuration versions
+ api_response = api_instance.get_running_config_versions()
+ print("The response of ConfigVersionsApi->get_running_config_versions:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ConfigVersionsApi->get_running_config_versions: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**RunningConfigVersionsResponse**](RunningConfigVersionsResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_config_versions**
+> ConfigVersionsListResponse list_config_versions(limit=limit, offset=offset)
+
+List configuration versions
+
+Retrieve a list of configuration versions.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.models.config_versions_list_response import ConfigVersionsListResponse
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.ConfigVersionsApi(api_client)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List configuration versions
+ api_response = api_instance.list_config_versions(limit=limit, offset=offset)
+ print("The response of ConfigVersionsApi->list_config_versions:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ConfigVersionsApi->list_config_versions: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**ConfigVersionsListResponse**](ConfigVersionsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **load_config_versions**
+> load_config_versions(load_config=load_config)
+
+Load config version
+
+Load a specific configuration version into the candidate configuration.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.models.load_config import LoadConfig
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.ConfigVersionsApi(api_client)
+ load_config = scm.config_operations.LoadConfig() # LoadConfig | Created (optional)
+
+ try:
+ # Load config version
+ api_instance.load_config_versions(load_config=load_config)
+ except Exception as e:
+ print("Exception when calling ConfigVersionsApi->load_config_versions: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **load_config** | [**LoadConfig**](LoadConfig.md)| Created | [optional]
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **push_candidate_config_versions**
+> push_candidate_config_versions(push_candidate_config_versions_request=push_candidate_config_versions_request)
+
+Push the candidate configuration
+
+Push the candidate configuration.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.models.push_candidate_config_versions_request import PushCandidateConfigVersionsRequest
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.ConfigVersionsApi(api_client)
+ push_candidate_config_versions_request = scm.config_operations.PushCandidateConfigVersionsRequest() # PushCandidateConfigVersionsRequest | Created (optional)
+
+ try:
+ # Push the candidate configuration
+ api_instance.push_candidate_config_versions(push_candidate_config_versions_request=push_candidate_config_versions_request)
+ except Exception as e:
+ print("Exception when calling ConfigVersionsApi->push_candidate_config_versions: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **push_candidate_config_versions_request** | [**PushCandidateConfigVersionsRequest**](PushCandidateConfigVersionsRequest.md)| Created | [optional]
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_operations/docs/ConfigVersionsListResponse.md b/scm/config_operations/docs/ConfigVersionsListResponse.md
new file mode 100644
index 00000000..b9ca3752
--- /dev/null
+++ b/scm/config_operations/docs/ConfigVersionsListResponse.md
@@ -0,0 +1,32 @@
+# ConfigVersionsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[ConfigVersion]**](ConfigVersion.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.config_operations.models.config_versions_list_response import ConfigVersionsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ConfigVersionsListResponse from a JSON string
+config_versions_list_response_instance = ConfigVersionsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(ConfigVersionsListResponse.to_json())
+
+# convert the object into a dict
+config_versions_list_response_dict = config_versions_list_response_instance.to_dict()
+# create an instance of ConfigVersionsListResponse from a dict
+config_versions_list_response_from_dict = ConfigVersionsListResponse.from_dict(config_versions_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/ErrorDetailCauseInfo.md b/scm/config_operations/docs/ErrorDetailCauseInfo.md
new file mode 100644
index 00000000..b63b7c3c
--- /dev/null
+++ b/scm/config_operations/docs/ErrorDetailCauseInfo.md
@@ -0,0 +1,32 @@
+# ErrorDetailCauseInfo
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **str** | | [optional]
+**details** | **object** | | [optional]
+**help** | **str** | | [optional]
+**message** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_operations.models.error_detail_cause_info import ErrorDetailCauseInfo
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ErrorDetailCauseInfo from a JSON string
+error_detail_cause_info_instance = ErrorDetailCauseInfo.from_json(json)
+# print the JSON string representation of the object
+print(ErrorDetailCauseInfo.to_json())
+
+# convert the object into a dict
+error_detail_cause_info_dict = error_detail_cause_info_instance.to_dict()
+# create an instance of ErrorDetailCauseInfo from a dict
+error_detail_cause_info_from_dict = ErrorDetailCauseInfo.from_dict(error_detail_cause_info_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/GenericError.md b/scm/config_operations/docs/GenericError.md
new file mode 100644
index 00000000..744eef57
--- /dev/null
+++ b/scm/config_operations/docs/GenericError.md
@@ -0,0 +1,30 @@
+# GenericError
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**errors** | [**List[ErrorDetailCauseInfo]**](ErrorDetailCauseInfo.md) | | [optional]
+**request_id** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_operations.models.generic_error import GenericError
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GenericError from a JSON string
+generic_error_instance = GenericError.from_json(json)
+# print the JSON string representation of the object
+print(GenericError.to_json())
+
+# convert the object into a dict
+generic_error_dict = generic_error_instance.to_dict()
+# create an instance of GenericError from a dict
+generic_error_from_dict = GenericError.from_dict(generic_error_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/Jobs.md b/scm/config_operations/docs/Jobs.md
new file mode 100644
index 00000000..5071d971
--- /dev/null
+++ b/scm/config_operations/docs/Jobs.md
@@ -0,0 +1,44 @@
+# Jobs
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | A description provided by the administrator or service account | [optional]
+**details** | **str** | JSON string with detailed errors or info | [optional]
+**device_name** | **str** | The name of the device |
+**end_ts** | **str** | The timestamp indicating when the job was finished |
+**id** | **str** | The job ID |
+**job_result** | **str** | The job result |
+**job_status** | **str** | The current status of the job |
+**job_type** | **str** | The job type |
+**parent_id** | **str** | The parent job ID |
+**percent** | **str** | Job completion percentage |
+**result_str** | **str** | The result of the job |
+**start_ts** | **str** | The timestamp indicating when the job was created |
+**status_str** | **str** | The current status of the job |
+**summary** | **str** | The completion summary of the job |
+**type_str** | **str** | The job type |
+**uname** | **str** | The administrator or service account that created the job |
+
+## Example
+
+```python
+from scm.config_operations.models.jobs import Jobs
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Jobs from a JSON string
+jobs_instance = Jobs.from_json(json)
+# print the JSON string representation of the object
+print(Jobs.to_json())
+
+# convert the object into a dict
+jobs_dict = jobs_instance.to_dict()
+# create an instance of Jobs from a dict
+jobs_from_dict = Jobs.from_dict(jobs_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/JobsApi.md b/scm/config_operations/docs/JobsApi.md
new file mode 100644
index 00000000..868a2d79
--- /dev/null
+++ b/scm/config_operations/docs/JobsApi.md
@@ -0,0 +1,172 @@
+# scm.config_operations.JobsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/operations/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**get_jobs_by_id**](JobsApi.md#get_jobs_by_id) | **GET** /jobs/{id} | Get a job
+[**list_jobs**](JobsApi.md#list_jobs) | **GET** /jobs | List jobs
+
+
+# **get_jobs_by_id**
+> JobsResponse get_jobs_by_id(id)
+
+Get a job
+
+Get an existing configuration job.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.models.jobs_response import JobsResponse
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.JobsApi(api_client)
+ id = 'id_example' # str | The ID of the job
+
+ try:
+ # Get a job
+ api_response = api_instance.get_jobs_by_id(id)
+ print("The response of JobsApi->get_jobs_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling JobsApi->get_jobs_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The ID of the job |
+
+### Return type
+
+[**JobsResponse**](JobsResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_jobs**
+> JobsListResponse list_jobs()
+
+List jobs
+
+Retrieve a list of configuration jobs.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_operations
+from scm.config_operations.models.jobs_list_response import JobsListResponse
+from scm.config_operations.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/operations/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_operations.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/operations/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_operations.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_operations.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_operations.JobsApi(api_client)
+
+ try:
+ # List jobs
+ api_response = api_instance.list_jobs()
+ print("The response of JobsApi->list_jobs:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling JobsApi->list_jobs: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**JobsListResponse**](JobsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_operations/docs/JobsListResponse.md b/scm/config_operations/docs/JobsListResponse.md
new file mode 100644
index 00000000..789ec71d
--- /dev/null
+++ b/scm/config_operations/docs/JobsListResponse.md
@@ -0,0 +1,32 @@
+# JobsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[Jobs]**](Jobs.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.config_operations.models.jobs_list_response import JobsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of JobsListResponse from a JSON string
+jobs_list_response_instance = JobsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(JobsListResponse.to_json())
+
+# convert the object into a dict
+jobs_list_response_dict = jobs_list_response_instance.to_dict()
+# create an instance of JobsListResponse from a dict
+jobs_list_response_from_dict = JobsListResponse.from_dict(jobs_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/JobsResponse.md b/scm/config_operations/docs/JobsResponse.md
new file mode 100644
index 00000000..c5145771
--- /dev/null
+++ b/scm/config_operations/docs/JobsResponse.md
@@ -0,0 +1,30 @@
+# JobsResponse
+
+Response containing job data
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[Jobs]**](Jobs.md) | | [optional]
+
+## Example
+
+```python
+from scm.config_operations.models.jobs_response import JobsResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of JobsResponse from a JSON string
+jobs_response_instance = JobsResponse.from_json(json)
+# print the JSON string representation of the object
+print(JobsResponse.to_json())
+
+# convert the object into a dict
+jobs_response_dict = jobs_response_instance.to_dict()
+# create an instance of JobsResponse from a dict
+jobs_response_from_dict = JobsResponse.from_dict(jobs_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/LoadConfig.md b/scm/config_operations/docs/LoadConfig.md
new file mode 100644
index 00000000..ccf4f059
--- /dev/null
+++ b/scm/config_operations/docs/LoadConfig.md
@@ -0,0 +1,29 @@
+# LoadConfig
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**version** | **int** | | [optional]
+
+## Example
+
+```python
+from scm.config_operations.models.load_config import LoadConfig
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LoadConfig from a JSON string
+load_config_instance = LoadConfig.from_json(json)
+# print the JSON string representation of the object
+print(LoadConfig.to_json())
+
+# convert the object into a dict
+load_config_dict = load_config_instance.to_dict()
+# create an instance of LoadConfig from a dict
+load_config_from_dict = LoadConfig.from_dict(load_config_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/PushCandidateConfigVersionsRequest.md b/scm/config_operations/docs/PushCandidateConfigVersionsRequest.md
new file mode 100644
index 00000000..42a99af0
--- /dev/null
+++ b/scm/config_operations/docs/PushCandidateConfigVersionsRequest.md
@@ -0,0 +1,32 @@
+# PushCandidateConfigVersionsRequest
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**admin** | **List[str]** | List the administrators and/or service accounts in this field. If you want to push folder named All, please do not add this admin field at all and list each of the folders under All in the folder field. | [optional]
+**description** | **str** | A description of the changes being pushed | [optional]
+**devices** | **List[float]** | The target devices for the configuration push | [optional]
+**folder** | **List[str]** | The target folders for the configuration push | [optional]
+
+## Example
+
+```python
+from scm.config_operations.models.push_candidate_config_versions_request import PushCandidateConfigVersionsRequest
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of PushCandidateConfigVersionsRequest from a JSON string
+push_candidate_config_versions_request_instance = PushCandidateConfigVersionsRequest.from_json(json)
+# print the JSON string representation of the object
+print(PushCandidateConfigVersionsRequest.to_json())
+
+# convert the object into a dict
+push_candidate_config_versions_request_dict = push_candidate_config_versions_request_instance.to_dict()
+# create an instance of PushCandidateConfigVersionsRequest from a dict
+push_candidate_config_versions_request_from_dict = PushCandidateConfigVersionsRequest.from_dict(push_candidate_config_versions_request_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/RunningConfigVersionsResponse.md b/scm/config_operations/docs/RunningConfigVersionsResponse.md
new file mode 100644
index 00000000..daa5c4e7
--- /dev/null
+++ b/scm/config_operations/docs/RunningConfigVersionsResponse.md
@@ -0,0 +1,33 @@
+# RunningConfigVersionsResponse
+
+Paginated response containing running configuration versions
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[RunningVersions]**](RunningVersions.md) | | [optional]
+**limit** | **int** | | [optional]
+**offset** | **int** | | [optional]
+**total** | **int** | | [optional]
+
+## Example
+
+```python
+from scm.config_operations.models.running_config_versions_response import RunningConfigVersionsResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RunningConfigVersionsResponse from a JSON string
+running_config_versions_response_instance = RunningConfigVersionsResponse.from_json(json)
+# print the JSON string representation of the object
+print(RunningConfigVersionsResponse.to_json())
+
+# convert the object into a dict
+running_config_versions_response_dict = running_config_versions_response_instance.to_dict()
+# create an instance of RunningConfigVersionsResponse from a dict
+running_config_versions_response_from_dict = RunningConfigVersionsResponse.from_dict(running_config_versions_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/docs/RunningVersions.md b/scm/config_operations/docs/RunningVersions.md
new file mode 100644
index 00000000..f5adafad
--- /dev/null
+++ b/scm/config_operations/docs/RunningVersions.md
@@ -0,0 +1,31 @@
+# RunningVersions
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**var_date** | **datetime** | The timestamp of when the configuration version was pushed to the folder or firewall |
+**device** | **str** | The folder name or firewall serial number |
+**version** | **int** | The configuration version number |
+
+## Example
+
+```python
+from scm.config_operations.models.running_versions import RunningVersions
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RunningVersions from a JSON string
+running_versions_instance = RunningVersions.from_json(json)
+# print the JSON string representation of the object
+print(RunningVersions.to_json())
+
+# convert the object into a dict
+running_versions_dict = running_versions_instance.to_dict()
+# create an instance of RunningVersions from a dict
+running_versions_from_dict = RunningVersions.from_dict(running_versions_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_operations/exceptions.py b/scm/config_operations/exceptions.py
new file mode 100644
index 00000000..23a88cac
--- /dev/null
+++ b/scm/config_operations/exceptions.py
@@ -0,0 +1,200 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+from typing import Any, Optional
+from typing_extensions import Self
+
+class OpenApiException(Exception):
+ """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+ def __init__(self, msg, path_to_item=None, valid_classes=None,
+ key_type=None) -> None:
+ """ Raises an exception for TypeErrors
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list): a list of keys an indices to get to the
+ current_item
+ None if unset
+ valid_classes (tuple): the primitive classes that current item
+ should be an instance of
+ None if unset
+ key_type (bool): False if our value is a value in a dict
+ True if it is a key in a dict
+ False if our item is an item in a list
+ None if unset
+ """
+ self.path_to_item = path_to_item
+ self.valid_classes = valid_classes
+ self.key_type = key_type
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list) the path to the exception in the
+ received_data dict. None if unset
+ """
+
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Raised when an attribute reference or assignment fails.
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+ def __init__(
+ self,
+ status=None,
+ reason=None,
+ http_resp=None,
+ *,
+ body: Optional[str] = None,
+ data: Optional[Any] = None,
+ ) -> None:
+ self.status = status
+ self.reason = reason
+ self.body = body
+ self.data = data
+ self.headers = None
+
+ if http_resp:
+ if self.status is None:
+ self.status = http_resp.status
+ if self.reason is None:
+ self.reason = http_resp.reason
+ if self.body is None:
+ try:
+ self.body = http_resp.data.decode('utf-8')
+ except Exception:
+ pass
+ self.headers = http_resp.getheaders()
+
+ @classmethod
+ def from_response(
+ cls,
+ *,
+ http_resp,
+ body: Optional[str],
+ data: Optional[Any],
+ ) -> Self:
+ if http_resp.status == 400:
+ raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 401:
+ raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 403:
+ raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 404:
+ raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+ if 500 <= http_resp.status <= 599:
+ raise ServiceException(http_resp=http_resp, body=body, data=data)
+ raise ApiException(http_resp=http_resp, body=body, data=data)
+
+ def __str__(self):
+ """Custom error messages for exception"""
+ error_message = "({0})\n"\
+ "Reason: {1}\n".format(self.status, self.reason)
+ if self.headers:
+ error_message += "HTTP response headers: {0}\n".format(
+ self.headers)
+
+ if self.data or self.body:
+ error_message += "HTTP response body: {0}\n".format(self.data or self.body)
+
+ return error_message
+
+
+class BadRequestException(ApiException):
+ pass
+
+
+class NotFoundException(ApiException):
+ pass
+
+
+class UnauthorizedException(ApiException):
+ pass
+
+
+class ForbiddenException(ApiException):
+ pass
+
+
+class ServiceException(ApiException):
+ pass
+
+
+def render_path(path_to_item):
+ """Returns a string representation of a path"""
+ result = ""
+ for pth in path_to_item:
+ if isinstance(pth, int):
+ result += "[{0}]".format(pth)
+ else:
+ result += "['{0}']".format(pth)
+ return result
diff --git a/scm/config_operations/models/__init__.py b/scm/config_operations/models/__init__.py
new file mode 100644
index 00000000..11cca852
--- /dev/null
+++ b/scm/config_operations/models/__init__.py
@@ -0,0 +1,28 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+# import models into model package
+from scm.config_operations.models.config_version import ConfigVersion
+from scm.config_operations.models.config_versions_list_response import ConfigVersionsListResponse
+from scm.config_operations.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.config_operations.models.generic_error import GenericError
+from scm.config_operations.models.jobs import Jobs
+from scm.config_operations.models.jobs_list_response import JobsListResponse
+from scm.config_operations.models.jobs_response import JobsResponse
+from scm.config_operations.models.load_config import LoadConfig
+from scm.config_operations.models.push_candidate_config_versions_request import PushCandidateConfigVersionsRequest
+from scm.config_operations.models.running_config_versions_response import RunningConfigVersionsResponse
+from scm.config_operations.models.running_versions import RunningVersions
diff --git a/scm/config_operations/models/config_version.py b/scm/config_operations/models/config_version.py
new file mode 100644
index 00000000..ee470368
--- /dev/null
+++ b/scm/config_operations/models/config_version.py
@@ -0,0 +1,115 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ConfigVersion(BaseModel):
+ """
+ ConfigVersion
+ """ # noqa: E501
+ admin: StrictStr = Field(description="The administrator or service account that pushed this configuration version")
+ created: Union[StrictFloat, StrictInt]
+ var_date: datetime = Field(alias="date")
+ deleted: Union[StrictFloat, StrictInt]
+ description: StrictStr
+ edited_by: Optional[StrictStr] = None
+ id: StrictInt = Field(description="The configuration version")
+ impacted_devices: Optional[StrictStr] = None
+ ngfw_scope: Optional[StrictStr] = Field(default=None, description="A comma separated list of firewall serial numbers")
+ scope: StrictStr
+ swg_config: Optional[StrictStr] = None
+ types: Optional[StrictStr] = None
+ updated: Union[StrictFloat, StrictInt]
+ version: StrictStr = Field(description="The configuration version name")
+ __properties: ClassVar[List[str]] = ["admin", "created", "date", "deleted", "description", "edited_by", "id", "impacted_devices", "ngfw_scope", "scope", "swg_config", "types", "updated", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ConfigVersion from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ConfigVersion from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "admin": obj.get("admin"),
+ "created": obj.get("created"),
+ "date": obj.get("date"),
+ "deleted": obj.get("deleted"),
+ "description": obj.get("description"),
+ "edited_by": obj.get("edited_by"),
+ "id": obj.get("id"),
+ "impacted_devices": obj.get("impacted_devices"),
+ "ngfw_scope": obj.get("ngfw_scope"),
+ "scope": obj.get("scope"),
+ "swg_config": obj.get("swg_config"),
+ "types": obj.get("types"),
+ "updated": obj.get("updated"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/config_versions_list_response.py b/scm/config_operations/models/config_versions_list_response.py
new file mode 100644
index 00000000..1e5fbfad
--- /dev/null
+++ b/scm/config_operations/models/config_versions_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.config_operations.models.config_version import ConfigVersion
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ConfigVersionsListResponse(BaseModel):
+ """
+ ConfigVersionsListResponse
+ """ # noqa: E501
+ data: List[ConfigVersion]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ConfigVersionsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ConfigVersionsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = ConfigVersion.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [ConfigVersion.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/error_detail_cause_info.py b/scm/config_operations/models/error_detail_cause_info.py
new file mode 100644
index 00000000..8af0e32d
--- /dev/null
+++ b/scm/config_operations/models/error_detail_cause_info.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorDetailCauseInfo(BaseModel):
+ """
+ ErrorDetailCauseInfo
+ """ # noqa: E501
+ code: Optional[StrictStr] = None
+ details: Optional[Dict[str, Any]] = None
+ help: Optional[StrictStr] = None
+ message: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["code", "details", "help", "message"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "code": obj.get("code"),
+ "details": obj.get("details"),
+ "help": obj.get("help"),
+ "message": obj.get("message")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/generic_error.py b/scm/config_operations/models/generic_error.py
new file mode 100644
index 00000000..59f792f3
--- /dev/null
+++ b/scm/config_operations/models/generic_error.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_operations.models.error_detail_cause_info import ErrorDetailCauseInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GenericError(BaseModel):
+ """
+ GenericError
+ """ # noqa: E501
+ errors: Optional[List[ErrorDetailCauseInfo]] = Field(default=None, alias="_errors")
+ request_id: Optional[StrictStr] = Field(default=None, alias="_request_id")
+ __properties: ClassVar[List[str]] = ["_errors", "_request_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GenericError from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+ _items = []
+ if self.errors:
+ for _item_errors in self.errors:
+ if _item_errors:
+ _items.append(_item_errors.to_dict())
+ _dict['_errors'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GenericError from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "_errors": [ErrorDetailCauseInfo.from_dict(_item) for _item in obj["_errors"]] if obj.get("_errors") is not None else None,
+ "_request_id": obj.get("_request_id")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/jobs.py b/scm/config_operations/models/jobs.py
new file mode 100644
index 00000000..46dac9f7
--- /dev/null
+++ b/scm/config_operations/models/jobs.py
@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Jobs(BaseModel):
+ """
+ Jobs
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default=None, description="A description provided by the administrator or service account")
+ details: Optional[StrictStr] = Field(default=None, description="JSON string with detailed errors or info")
+ device_name: StrictStr = Field(description="The name of the device")
+ end_ts: StrictStr = Field(description="The timestamp indicating when the job was finished")
+ id: StrictStr = Field(description="The job ID")
+ job_result: StrictStr = Field(description="The job result")
+ job_status: StrictStr = Field(description="The current status of the job")
+ job_type: StrictStr = Field(description="The job type")
+ parent_id: StrictStr = Field(description="The parent job ID")
+ percent: StrictStr = Field(description="Job completion percentage")
+ result_str: StrictStr = Field(description="The result of the job")
+ start_ts: StrictStr = Field(description="The timestamp indicating when the job was created")
+ status_str: StrictStr = Field(description="The current status of the job")
+ summary: StrictStr = Field(description="The completion summary of the job")
+ type_str: StrictStr = Field(description="The job type")
+ uname: StrictStr = Field(description="The administrator or service account that created the job")
+ __properties: ClassVar[List[str]] = ["description", "details", "device_name", "end_ts", "id", "job_result", "job_status", "job_type", "parent_id", "percent", "result_str", "start_ts", "status_str", "summary", "type_str", "uname"]
+
+ @field_validator('result_str')
+ def result_str_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['OK', 'FAIL', 'PEND', 'WAIT', 'CANCELLED', 'TIMEOUT']):
+ raise ValueError("must be one of enum values ('OK', 'FAIL', 'PEND', 'WAIT', 'CANCELLED', 'TIMEOUT')")
+ return value
+
+ @field_validator('status_str')
+ def status_str_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['ACT', 'FIN', 'PEND', 'PUSHSENT', 'PUSHFAIL', 'PUSHABORT', 'PUSHTIMEOUT']):
+ raise ValueError("must be one of enum values ('ACT', 'FIN', 'PEND', 'PUSHSENT', 'PUSHFAIL', 'PUSHABORT', 'PUSHTIMEOUT')")
+ return value
+
+ @field_validator('type_str')
+ def type_str_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['CommitAll', 'CommitAndPush', 'NGFW-Bootstrap-Push', 'Validate']):
+ raise ValueError("must be one of enum values ('CommitAll', 'CommitAndPush', 'NGFW-Bootstrap-Push', 'Validate')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Jobs from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Jobs from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "details": obj.get("details"),
+ "device_name": obj.get("device_name"),
+ "end_ts": obj.get("end_ts"),
+ "id": obj.get("id"),
+ "job_result": obj.get("job_result"),
+ "job_status": obj.get("job_status"),
+ "job_type": obj.get("job_type"),
+ "parent_id": obj.get("parent_id"),
+ "percent": obj.get("percent"),
+ "result_str": obj.get("result_str"),
+ "start_ts": obj.get("start_ts"),
+ "status_str": obj.get("status_str"),
+ "summary": obj.get("summary"),
+ "type_str": obj.get("type_str"),
+ "uname": obj.get("uname")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/jobs_list_response.py b/scm/config_operations/models/jobs_list_response.py
new file mode 100644
index 00000000..65246b2a
--- /dev/null
+++ b/scm/config_operations/models/jobs_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.config_operations.models.jobs import Jobs
+from typing import Optional, Set
+from typing_extensions import Self
+
+class JobsListResponse(BaseModel):
+ """
+ JobsListResponse
+ """ # noqa: E501
+ data: List[Jobs]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of JobsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of JobsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = Jobs.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [Jobs.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/jobs_response.py b/scm/config_operations/models/jobs_response.py
new file mode 100644
index 00000000..94aa6096
--- /dev/null
+++ b/scm/config_operations/models/jobs_response.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_operations.models.jobs import Jobs
+from typing import Optional, Set
+from typing_extensions import Self
+
+class JobsResponse(BaseModel):
+ """
+ Response containing job data
+ """ # noqa: E501
+ data: Optional[List[Jobs]] = None
+ __properties: ClassVar[List[str]] = ["data"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of JobsResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of JobsResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "data": [Jobs.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/load_config.py b/scm/config_operations/models/load_config.py
new file mode 100644
index 00000000..e4dfa082
--- /dev/null
+++ b/scm/config_operations/models/load_config.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LoadConfig(BaseModel):
+ """
+ LoadConfig
+ """ # noqa: E501
+ version: Optional[StrictInt] = None
+ __properties: ClassVar[List[str]] = ["version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LoadConfig from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LoadConfig from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/push_candidate_config_versions_request.py b/scm/config_operations/models/push_candidate_config_versions_request.py
new file mode 100644
index 00000000..f0e65b92
--- /dev/null
+++ b/scm/config_operations/models/push_candidate_config_versions_request.py
@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PushCandidateConfigVersionsRequest(BaseModel):
+ """
+ PushCandidateConfigVersionsRequest
+ """ # noqa: E501
+ admin: Optional[List[StrictStr]] = Field(default=None, description="List the administrators and/or service accounts in this field. If you want to push folder named All, please do not add this admin field at all and list each of the folders under All in the folder field.")
+ description: Optional[StrictStr] = Field(default=None, description="A description of the changes being pushed")
+ devices: Optional[List[Union[Annotated[float, Field(strict=True)], Annotated[int, Field(strict=True)]]]] = Field(default=None, description="The target devices for the configuration push")
+ folder: Optional[List[Annotated[str, Field(strict=True, max_length=64)]]] = Field(default=None, description="The target folders for the configuration push")
+ __properties: ClassVar[List[str]] = ["admin", "description", "devices", "folder"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of PushCandidateConfigVersionsRequest from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of PushCandidateConfigVersionsRequest from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "admin": obj.get("admin"),
+ "description": obj.get("description"),
+ "devices": obj.get("devices"),
+ "folder": obj.get("folder")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/running_config_versions_response.py b/scm/config_operations/models/running_config_versions_response.py
new file mode 100644
index 00000000..1c7d6640
--- /dev/null
+++ b/scm/config_operations/models/running_config_versions_response.py
@@ -0,0 +1,102 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_operations.models.running_versions import RunningVersions
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RunningConfigVersionsResponse(BaseModel):
+ """
+ Paginated response containing running configuration versions
+ """ # noqa: E501
+ data: Optional[List[RunningVersions]] = None
+ limit: Optional[StrictInt] = None
+ offset: Optional[StrictInt] = None
+ total: Optional[StrictInt] = None
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RunningConfigVersionsResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RunningConfigVersionsResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "data": [RunningVersions.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit"),
+ "offset": obj.get("offset"),
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/models/running_versions.py b/scm/config_operations/models/running_versions.py
new file mode 100644
index 00000000..6f1d4ed5
--- /dev/null
+++ b/scm/config_operations/models/running_versions.py
@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RunningVersions(BaseModel):
+ """
+ RunningVersions
+ """ # noqa: E501
+ var_date: datetime = Field(description="The timestamp of when the configuration version was pushed to the folder or firewall", alias="date")
+ device: StrictStr = Field(description="The folder name or firewall serial number")
+ version: StrictInt = Field(description="The configuration version number")
+ __properties: ClassVar[List[str]] = ["date", "device", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RunningVersions from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RunningVersions from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "date": obj.get("date"),
+ "device": obj.get("device"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_operations/rest.py b/scm/config_operations/rest.py
new file mode 100644
index 00000000..210f50c1
--- /dev/null
+++ b/scm/config_operations/rest.py
@@ -0,0 +1,258 @@
+# coding: utf-8
+
+"""
+ Config Operations
+
+ These APIs are used for Prisma Access and NGFW operations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import io
+import json
+import re
+import ssl
+
+import urllib3
+
+from scm.config_operations.exceptions import ApiException, ApiValueError
+
+SUPPORTED_SOCKS_PROXIES = {"socks5", "socks5h", "socks4", "socks4a"}
+RESTResponseType = urllib3.HTTPResponse
+
+
+def is_socks_proxy_url(url):
+ if url is None:
+ return False
+ split_section = url.split("://")
+ if len(split_section) < 2:
+ return False
+ else:
+ return split_section[0].lower() in SUPPORTED_SOCKS_PROXIES
+
+
+class RESTResponse(io.IOBase):
+
+ def __init__(self, resp) -> None:
+ self.response = resp
+ self.status = resp.status
+ self.reason = resp.reason
+ self.data = None
+
+ def read(self):
+ if self.data is None:
+ self.data = self.response.data
+ return self.data
+
+ def getheaders(self):
+ """Returns a dictionary of the response headers."""
+ return self.response.headers
+
+ def getheader(self, name, default=None):
+ """Returns a given response header."""
+ return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+ def __init__(self, configuration) -> None:
+ # urllib3.PoolManager will pass all kw parameters to connectionpool
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501
+ # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501
+
+ # cert_reqs
+ if configuration.verify_ssl:
+ cert_reqs = ssl.CERT_REQUIRED
+ else:
+ cert_reqs = ssl.CERT_NONE
+
+ pool_args = {
+ "cert_reqs": cert_reqs,
+ "ca_certs": configuration.ssl_ca_cert,
+ "cert_file": configuration.cert_file,
+ "key_file": configuration.key_file,
+ }
+ if configuration.assert_hostname is not None:
+ pool_args['assert_hostname'] = (
+ configuration.assert_hostname
+ )
+
+ if configuration.retries is not None:
+ pool_args['retries'] = configuration.retries
+
+ if configuration.tls_server_name:
+ pool_args['server_hostname'] = configuration.tls_server_name
+
+
+ if configuration.socket_options is not None:
+ pool_args['socket_options'] = configuration.socket_options
+
+ if configuration.connection_pool_maxsize is not None:
+ pool_args['maxsize'] = configuration.connection_pool_maxsize
+
+ # https pool manager
+ self.pool_manager: urllib3.PoolManager
+
+ if configuration.proxy:
+ if is_socks_proxy_url(configuration.proxy):
+ from urllib3.contrib.socks import SOCKSProxyManager
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["headers"] = configuration.proxy_headers
+ self.pool_manager = SOCKSProxyManager(**pool_args)
+ else:
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["proxy_headers"] = configuration.proxy_headers
+ self.pool_manager = urllib3.ProxyManager(**pool_args)
+ else:
+ self.pool_manager = urllib3.PoolManager(**pool_args)
+
+ def request(
+ self,
+ method,
+ url,
+ headers=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ):
+ """Perform requests.
+
+ :param method: http request method
+ :param url: http request url
+ :param headers: http request headers
+ :param body: request json body, for `application/json`
+ :param post_params: request post parameters,
+ `application/x-www-form-urlencoded`
+ and `multipart/form-data`
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ """
+ method = method.upper()
+ assert method in [
+ 'GET',
+ 'HEAD',
+ 'DELETE',
+ 'POST',
+ 'PUT',
+ 'PATCH',
+ 'OPTIONS'
+ ]
+
+ if post_params and body:
+ raise ApiValueError(
+ "body parameter cannot be used with post_params parameter."
+ )
+
+ post_params = post_params or {}
+ headers = headers or {}
+
+ timeout = None
+ if _request_timeout:
+ if isinstance(_request_timeout, (int, float)):
+ timeout = urllib3.Timeout(total=_request_timeout)
+ elif (
+ isinstance(_request_timeout, tuple)
+ and len(_request_timeout) == 2
+ ):
+ timeout = urllib3.Timeout(
+ connect=_request_timeout[0],
+ read=_request_timeout[1]
+ )
+
+ try:
+ # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+ if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+
+ # no content type provided or payload is json
+ content_type = headers.get('Content-Type')
+ if (
+ not content_type
+ or re.search('json', content_type, re.IGNORECASE)
+ ):
+ request_body = None
+ if body is not None:
+ request_body = json.dumps(body)
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'application/x-www-form-urlencoded':
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=False,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'multipart/form-data':
+ # must del headers['Content-Type'], or the correct
+ # Content-Type which generated by urllib3 will be
+ # overwritten.
+ del headers['Content-Type']
+ # Ensures that dict objects are serialized
+ post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a,b) for a, b in post_params]
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=True,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ # Pass a `string` parameter directly in the body to support
+ # other content types than JSON when `body` argument is
+ # provided in serialized form.
+ elif isinstance(body, str) or isinstance(body, bytes):
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif headers['Content-Type'].startswith('text/') and isinstance(body, bool):
+ request_body = "true" if body else "false"
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ preload_content=False,
+ timeout=timeout,
+ headers=headers)
+ else:
+ # Cannot generate the request from given parameters
+ msg = """Cannot prepare a request message for provided
+ arguments. Please check that your arguments match
+ declared content type."""
+ raise ApiException(status=0, reason=msg)
+ # For `GET`, `HEAD`
+ else:
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields={},
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ except urllib3.exceptions.SSLError as e:
+ msg = "\n".join([type(e).__name__, str(e)])
+ raise ApiException(status=0, reason=msg)
+
+ return RESTResponse(r)
diff --git a/scm/config_operations/tests/__init__.py b/scm/config_operations/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/scm/config_operations/tests/api_config_versions_test.py b/scm/config_operations/tests/api_config_versions_test.py
new file mode 100644
index 00000000..12fcce05
--- /dev/null
+++ b/scm/config_operations/tests/api_config_versions_test.py
@@ -0,0 +1,136 @@
+
+import logging
+import pytest
+from scm import Scm
+from scm.test_helpers import perform
+
+# Configure logging to see details during test execution (use pytest -s)
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ Assumes SCM_CLIENT_ID, SCM_CLIENT_SECRET, SCM_TSG_ID are set in env.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def config_versions_api(client):
+ """
+ Fixture to return the Config Versions API instance.
+ """
+ return client.config_operations.ConfigVersionsApi(client.config_operations.api_client)
+
+
+def test_list_config_versions(config_versions_api):
+ """
+ Test listing configuration versions.
+ This is a read-only operation that retrieves the list of config versions.
+ Equivalent to Go: Test_config_operations_ConfigVersionsAPIService_List
+ """
+ logger.info("\n[TEST] Listing configuration versions")
+
+ # List config versions using perform helper
+ response = perform(
+ config_versions_api.list_config_versions_with_http_info,
+ response_type=object # Response is paginated with data array
+ )
+
+ assert response is not None, "Response should not be None"
+ assert hasattr(response, 'data'), "Response should have 'data' attribute"
+
+ versions = response.data
+ logger.info(f"Successfully retrieved {len(versions)} config versions (limit: {response.limit}, offset: {response.offset}, total: {response.total})")
+
+ # If there are versions, verify the structure
+ if len(versions) > 0:
+ first_version = versions[0]
+ assert hasattr(first_version, 'id'), "Version should have an ID"
+ assert hasattr(first_version, 'version'), "Version should have a version string"
+
+ logger.info(f"Sample version - ID: {first_version.id}, Version: {first_version.version}, Date: {first_version.var_date}")
+ else:
+ logger.info("No config versions found in the system")
+
+
+def test_get_config_version_by_id(config_versions_api):
+ """
+ Test retrieving a specific config version by ID.
+ Note: Uses a hardcoded version number since we can't easily extract from list response.
+ Equivalent to Go: Test_config_operations_ConfigVersionsAPIService_GetByID
+ """
+ logger.info("\n[TEST] Getting config version by ID")
+
+ # Use version 1 as a test (this might not exist in all environments)
+ version_id = 1
+ logger.info(f"Testing GetByID with version: {version_id}")
+
+ try:
+ # Retrieve the specific version by ID
+ response = perform(
+ config_versions_api.get_config_versions_by_id_with_http_info,
+ response_type=object,
+ version=version_id
+ )
+
+ assert response is not None, "Response should not be None"
+
+ # The API returns an array with config versions (even for single ID lookup)
+ assert len(response) > 0, "Should have at least one config version in response"
+
+ # Get the first version from the array
+ version = response[0]
+ assert hasattr(version, 'id'), "Version should have an ID"
+ assert hasattr(version, 'version'), "Version should have a version string"
+
+ logger.info(f"Retrieved config version - ID: {version.id}, Version: {version.version}, Date: {version.var_date}, Admin: {version.admin}")
+
+ except Exception as e:
+ # This test may fail if version doesn't exist, which is acceptable
+ logger.info(f"Version {version_id} not found - this is expected if no configs exist: {e}")
+ pytest.skip(f"Version {version_id} not found - this is expected if no configs exist")
+
+
+def test_get_running_config_versions(config_versions_api):
+ """
+ Test retrieving the running configuration versions.
+ This is a read-only operation that retrieves the currently active configurations.
+ Equivalent to Go: Test_config_operations_ConfigVersionsAPIService_GetRunning
+ """
+ logger.info("\n[TEST] Retrieving running configuration versions")
+
+ # Get running config versions using perform helper
+ response = perform(
+ config_versions_api.get_running_config_versions_with_http_info,
+ response_type=object # Response is paginated with data array
+ )
+
+ assert response is not None, "Response should not be None"
+ assert hasattr(response, 'data'), "Response should have 'data' attribute"
+
+ running_versions = response.data
+ assert len(running_versions) > 0, "Should have at least one running version"
+
+ logger.info(f"Retrieved {len(running_versions)} running config versions (limit: {response.limit}, offset: {response.offset}, total: {response.total})")
+
+ # Verify the structure of the first running version
+ first_running = running_versions[0]
+ assert hasattr(first_running, 'device'), "Running version should have a device"
+ assert hasattr(first_running, 'version'), "Running version should have a version number"
+
+ logger.info(f"Sample running version - Device: {first_running.device}, Version: {first_running.version}, Date: {first_running.var_date}")
+
+
+# NOTE: The following operations are NOT tested as they are destructive/action operations:
+# - load_config_versions: This loads a candidate config (action operation)
+# - push_candidate_config_versions: This pushes config to devices (action operation)
+# - delete_candidate_config_versions: This deletes the candidate config (destructive operation)
+#
+# These operations should be tested in integration tests or manually in a controlled environment.
diff --git a/scm/config_operations/tests/api_jobs_test.py b/scm/config_operations/tests/api_jobs_test.py
new file mode 100644
index 00000000..363c8307
--- /dev/null
+++ b/scm/config_operations/tests/api_jobs_test.py
@@ -0,0 +1,108 @@
+
+import logging
+import pytest
+from scm import Scm
+from scm.test_helpers import perform
+
+# Configure logging to see details during test execution (use pytest -s)
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ Assumes SCM_CLIENT_ID, SCM_CLIENT_SECRET, SCM_TSG_ID are set in env.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def jobs_api(client):
+ """
+ Fixture to return the Jobs API instance.
+ """
+ return client.config_operations.JobsApi(client.config_operations.api_client)
+
+
+def test_list_jobs(jobs_api):
+ """
+ Test listing configuration jobs.
+ This is a read-only operation that retrieves the current list of jobs.
+ Equivalent to Go: Test_config_operations_JobsAPIService_List
+ """
+ logger.info("\n[TEST] Listing configuration jobs")
+
+ # List jobs using perform helper
+ response = perform(
+ jobs_api.list_jobs_with_http_info,
+ response_type=object # Response is JobsListResponse with data array
+ )
+
+ assert response is not None, "Response should not be None"
+ assert hasattr(response, 'data'), "Response should have 'data' attribute"
+
+ jobs = response.data
+ logger.info(f"Successfully retrieved {len(jobs)} jobs (limit: {response.limit}, offset: {response.offset}, total: {response.total})")
+
+ # If there are jobs, verify the structure
+ if len(jobs) > 0:
+ first_job = jobs[0]
+ assert hasattr(first_job, 'id'), "Job should have an ID"
+ assert hasattr(first_job, 'job_type'), "Job should have a job_type"
+ assert hasattr(first_job, 'status_str'), "Job should have a status_str"
+
+ logger.info(f"Sample job - ID: {first_job.id}, Type: {first_job.job_type}, Status: {first_job.status_str}")
+ else:
+ logger.info("No jobs found in the system")
+
+
+def test_get_job_by_id(jobs_api):
+ """
+ Test retrieving a specific job by ID.
+ First lists jobs to find a valid ID, then retrieves that specific job.
+ Equivalent to Go: Test_config_operations_JobsAPIService_GetByID
+ """
+ logger.info("\n[TEST] Getting job by ID")
+
+ # First, list jobs to get a valid job ID
+ list_response = perform(
+ jobs_api.list_jobs_with_http_info,
+ response_type=object
+ )
+
+ assert list_response is not None
+ jobs = list_response.data
+
+ # Skip test if no jobs exist
+ if len(jobs) == 0:
+ pytest.skip("No jobs available to test GetByID - skipping test")
+ return
+
+ # Get the first job's ID (string type)
+ job_id = jobs[0].id
+ logger.info(f"Retrieving job with ID: {job_id}")
+
+ # Retrieve the specific job by ID
+ response = perform(
+ jobs_api.get_jobs_by_id_with_http_info,
+ response_type=object,
+ id=job_id
+ )
+
+ assert response is not None, "Response should not be None"
+ assert hasattr(response, 'data'), "Response should have 'data' attribute"
+
+ # Get the data - API returns array with jobs
+ retrieved_jobs = response.data
+ assert len(retrieved_jobs) > 0, "Should have at least one job in response"
+
+ # Verify we got the job we requested
+ found_job = retrieved_jobs[0]
+ assert found_job.id == job_id, f"Retrieved job ID should match requested ID: {job_id}"
+
+ logger.info(f"Successfully retrieved job - ID: {found_job.id}, Type: {found_job.job_type}, Status: {found_job.status_str}")
diff --git a/scm/config_setup/__init__.py b/scm/config_setup/__init__.py
new file mode 100644
index 00000000..27d7b45c
--- /dev/null
+++ b/scm/config_setup/__init__.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from scm.config_setup.api.folders_api import FoldersApi
+from scm.config_setup.api.labels_api import LabelsApi
+from scm.config_setup.api.shared_snippets_api import SharedSnippetsApi
+from scm.config_setup.api.snippet_audit_logs_api import SnippetAuditLogsApi
+from scm.config_setup.api.snippet_categories_api import SnippetCategoriesApi
+from scm.config_setup.api.snippet_snapshots_api import SnippetSnapshotsApi
+from scm.config_setup.api.snippets_api import SnippetsApi
+from scm.config_setup.api.subscribed_tenants_api import SubscribedTenantsApi
+from scm.config_setup.api.trust_information_api import TrustInformationApi
+from scm.config_setup.api.trust_validations_api import TrustValidationsApi
+from scm.config_setup.api.trusted_tenants_overview_api import TrustedTenantsOverviewApi
+from scm.config_setup.api.trusts_api import TrustsApi
+from scm.config_setup.api.variables_api import VariablesApi
+
+# import ApiClient
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.api_client import ApiClient
+from scm.config_setup.configuration import Configuration
+from scm.config_setup.exceptions import OpenApiException
+from scm.config_setup.exceptions import ApiTypeError
+from scm.config_setup.exceptions import ApiValueError
+from scm.config_setup.exceptions import ApiKeyError
+from scm.config_setup.exceptions import ApiAttributeError
+from scm.config_setup.exceptions import ApiException
+
+# import models into sdk package
+from scm.config_setup.models.add_subscriber_request_payload_inner import AddSubscriberRequestPayloadInner
+from scm.config_setup.models.common_snippet_snapshot_payload import CommonSnippetSnapshotPayload
+from scm.config_setup.models.compare_snippet_snapshot_config_payload import CompareSnippetSnapshotConfigPayload
+from scm.config_setup.models.compare_tlo_payload import CompareTloPayload
+from scm.config_setup.models.deleted_subscriber import DeletedSubscriber
+from scm.config_setup.models.devices import Devices
+from scm.config_setup.models.devices_available_licensess_inner import DevicesAvailableLicensessInner
+from scm.config_setup.models.devices_installed_licenses_inner import DevicesInstalledLicensesInner
+from scm.config_setup.models.devices_put import DevicesPut
+from scm.config_setup.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.config_setup.models.folders import Folders
+from scm.config_setup.models.folders_list_response import FoldersListResponse
+from scm.config_setup.models.generic_error import GenericError
+from scm.config_setup.models.labels import Labels
+from scm.config_setup.models.labels_list_response import LabelsListResponse
+from scm.config_setup.models.property_item import PropertyItem
+from scm.config_setup.models.save_snippet_snapshot_config_response import SaveSnippetSnapshotConfigResponse
+from scm.config_setup.models.save_snippet_snapshot_config_response_result import SaveSnippetSnapshotConfigResponseResult
+from scm.config_setup.models.save_snippet_snapshot_payload import SaveSnippetSnapshotPayload
+from scm.config_setup.models.snippet_audit_history import SnippetAuditHistory
+from scm.config_setup.models.snippet_audit_payload import SnippetAuditPayload
+from scm.config_setup.models.snippet_categories import SnippetCategories
+from scm.config_setup.models.snippet_categories_list_response import SnippetCategoriesListResponse
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from scm.config_setup.models.snippet_share_load_payload import SnippetShareLoadPayload
+from scm.config_setup.models.snippet_share_property import SnippetShareProperty
+from scm.config_setup.models.snippet_share_upload_payload import SnippetShareUploadPayload
+from scm.config_setup.models.snippet_snapshot_compare_entry import SnippetSnapshotCompareEntry
+from scm.config_setup.models.snippet_snapshot_diff_response import SnippetSnapshotDiffResponse
+from scm.config_setup.models.snippet_snapshot_diff_response_after import SnippetSnapshotDiffResponseAfter
+from scm.config_setup.models.snippet_snapshot_diff_response_before import SnippetSnapshotDiffResponseBefore
+from scm.config_setup.models.snippet_snapshot_load_snippet_payload import SnippetSnapshotLoadSnippetPayload
+from scm.config_setup.models.snippet_snapshot_load_snippet_response import SnippetSnapshotLoadSnippetResponse
+from scm.config_setup.models.snippet_snapshot_publish_request import SnippetSnapshotPublishRequest
+from scm.config_setup.models.snippet_snapshot_publish_response import SnippetSnapshotPublishResponse
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_payload import SnippetSnapshotSubscriberComparePayload
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response import SnippetSnapshotSubscriberCompareResponse
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response_publisher import SnippetSnapshotSubscriberCompareResponsePublisher
+from scm.config_setup.models.snippets import Snippets
+from scm.config_setup.models.snippets_list_response import SnippetsListResponse
+from scm.config_setup.models.subscriber_property_payload import SubscriberPropertyPayload
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+from scm.config_setup.models.trust_info_with_shared_snippets import TrustInfoWithSharedSnippets
+from scm.config_setup.models.trusted_tenant_overview import TrustedTenantOverview
+from scm.config_setup.models.trusted_tenant_overview_publisher import TrustedTenantOverviewPublisher
+from scm.config_setup.models.trusts import Trusts
+from scm.config_setup.models.trusts_validation_payload import TrustsValidationPayload
+from scm.config_setup.models.used_folders import UsedFolders
+from scm.config_setup.models.variables import Variables
+from scm.config_setup.models.variables_list_response import VariablesListResponse
diff --git a/scm/config_setup/api/__init__.py b/scm/config_setup/api/__init__.py
new file mode 100644
index 00000000..0f22710d
--- /dev/null
+++ b/scm/config_setup/api/__init__.py
@@ -0,0 +1,17 @@
+# flake8: noqa
+
+# import apis into api package
+from scm.config_setup.api.folders_api import FoldersApi
+from scm.config_setup.api.labels_api import LabelsApi
+from scm.config_setup.api.shared_snippets_api import SharedSnippetsApi
+from scm.config_setup.api.snippet_audit_logs_api import SnippetAuditLogsApi
+from scm.config_setup.api.snippet_categories_api import SnippetCategoriesApi
+from scm.config_setup.api.snippet_snapshots_api import SnippetSnapshotsApi
+from scm.config_setup.api.snippets_api import SnippetsApi
+from scm.config_setup.api.subscribed_tenants_api import SubscribedTenantsApi
+from scm.config_setup.api.trust_information_api import TrustInformationApi
+from scm.config_setup.api.trust_validations_api import TrustValidationsApi
+from scm.config_setup.api.trusted_tenants_overview_api import TrustedTenantsOverviewApi
+from scm.config_setup.api.trusts_api import TrustsApi
+from scm.config_setup.api.variables_api import VariablesApi
+
diff --git a/scm/config_setup/api/folders_api.py b/scm/config_setup/api/folders_api.py
new file mode 100644
index 00000000..962e8b1e
--- /dev/null
+++ b/scm/config_setup/api/folders_api.py
@@ -0,0 +1,1556 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.folders import Folders
+from scm.config_setup.models.folders_list_response import FoldersListResponse
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class FoldersApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_folder(
+ self,
+ folders: Annotated[Optional[Folders], Field(description="The `folder` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Folders:
+ """Create a folder
+
+ Create a new folder.
+
+ :param folders: The `folder` resource definition
+ :type folders: Folders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_folder_serialize(
+ folders=folders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_folder_with_http_info(
+ self,
+ folders: Annotated[Optional[Folders], Field(description="The `folder` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Folders]:
+ """Create a folder
+
+ Create a new folder.
+
+ :param folders: The `folder` resource definition
+ :type folders: Folders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_folder_serialize(
+ folders=folders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_folder_without_preload_content(
+ self,
+ folders: Annotated[Optional[Folders], Field(description="The `folder` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a folder
+
+ Create a new folder.
+
+ :param folders: The `folder` resource definition
+ :type folders: Folders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_folder_serialize(
+ folders=folders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_folder_serialize(
+ self,
+ folders,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if folders is not None:
+ _body_params = folders
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/folders',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_folder_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a folder
+
+ Delete an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_folder_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_folder_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a folder
+
+ Delete an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_folder_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_folder_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a folder
+
+ Delete an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_folder_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_folder_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/folders/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_folder_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Folders:
+ """Get a folder
+
+ Retrieve an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_folder_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_folder_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Folders]:
+ """Get a folder
+
+ Retrieve an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_folder_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_folder_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a folder
+
+ Retrieve an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_folder_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_folder_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/folders/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_folders(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> FoldersListResponse:
+ """List folders
+
+ Retrieve a list of folders.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_folders_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "FoldersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_folders_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[FoldersListResponse]:
+ """List folders
+
+ Retrieve a list of folders.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_folders_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "FoldersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_folders_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List folders
+
+ Retrieve a list of folders.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_folders_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "FoldersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_folders_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/folders',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_folder_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ folders: Annotated[Optional[Folders], Field(description="The `folder` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Folders:
+ """Update a folder
+
+ Update an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param folders: The `folder` resource definition.
+ :type folders: Folders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_folder_by_id_serialize(
+ id=id,
+ folders=folders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_folder_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ folders: Annotated[Optional[Folders], Field(description="The `folder` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Folders]:
+ """Update a folder
+
+ Update an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param folders: The `folder` resource definition.
+ :type folders: Folders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_folder_by_id_serialize(
+ id=id,
+ folders=folders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_folder_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ folders: Annotated[Optional[Folders], Field(description="The `folder` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a folder
+
+ Update an existing folder.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param folders: The `folder` resource definition.
+ :type folders: Folders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_folder_by_id_serialize(
+ id=id,
+ folders=folders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Folders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_folders(
+ self,
+ name: str,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single folders object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name.
+
+ Args:
+ name: The name of the object to fetch
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_folders(name="my-object")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_folders(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_folder_by_id_serialize(
+ self,
+ id,
+ folders,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if folders is not None:
+ _body_params = folders
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/folders/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/labels_api.py b/scm/config_setup/api/labels_api.py
new file mode 100644
index 00000000..f4482f6f
--- /dev/null
+++ b/scm/config_setup/api/labels_api.py
@@ -0,0 +1,1556 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.labels import Labels
+from scm.config_setup.models.labels_list_response import LabelsListResponse
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LabelsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_label(
+ self,
+ labels: Annotated[Optional[Labels], Field(description="The `label` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Labels:
+ """Create a label
+
+ Create a new label.
+
+ :param labels: The `label` resource definition.
+ :type labels: Labels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_label_serialize(
+ labels=labels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_label_with_http_info(
+ self,
+ labels: Annotated[Optional[Labels], Field(description="The `label` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Labels]:
+ """Create a label
+
+ Create a new label.
+
+ :param labels: The `label` resource definition.
+ :type labels: Labels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_label_serialize(
+ labels=labels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_label_without_preload_content(
+ self,
+ labels: Annotated[Optional[Labels], Field(description="The `label` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a label
+
+ Create a new label.
+
+ :param labels: The `label` resource definition.
+ :type labels: Labels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_label_serialize(
+ labels=labels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_label_serialize(
+ self,
+ labels,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if labels is not None:
+ _body_params = labels
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/labels',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_label_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a label
+
+ Delete an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_label_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_label_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a label
+
+ Delete an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_label_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_label_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a label
+
+ Delete an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_label_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_label_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/labels/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_label_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Labels:
+ """Get a label
+
+ Retrieve an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_label_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_label_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Labels]:
+ """Get a label
+
+ Retrieve an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_label_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_label_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a label
+
+ Retrieve an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_label_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_label_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/labels/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_labels(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LabelsListResponse:
+ """List labels
+
+ Retrieve a list of labels.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_labels_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LabelsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_labels_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LabelsListResponse]:
+ """List labels
+
+ Retrieve a list of labels.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_labels_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LabelsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_labels_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List labels
+
+ Retrieve a list of labels.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_labels_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LabelsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_labels_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/labels',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_label_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ labels: Annotated[Optional[Labels], Field(description="The `label` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Labels:
+ """Update a label
+
+ Update an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param labels: The `label` resource definition.
+ :type labels: Labels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_label_by_id_serialize(
+ id=id,
+ labels=labels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_label_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ labels: Annotated[Optional[Labels], Field(description="The `label` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Labels]:
+ """Update a label
+
+ Update an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param labels: The `label` resource definition.
+ :type labels: Labels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_label_by_id_serialize(
+ id=id,
+ labels=labels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_label_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ labels: Annotated[Optional[Labels], Field(description="The `label` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a label
+
+ Update an existing label.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param labels: The `label` resource definition.
+ :type labels: Labels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_label_by_id_serialize(
+ id=id,
+ labels=labels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Labels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_labels(
+ self,
+ name: str,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single labels object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name.
+
+ Args:
+ name: The name of the object to fetch
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_labels(name="my-object")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_labels(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_label_by_id_serialize(
+ self,
+ id,
+ labels,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if labels is not None:
+ _body_params = labels
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/labels/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/shared_snippets_api.py b/scm/config_setup/api/shared_snippets_api.py
new file mode 100644
index 00000000..a80de5cc
--- /dev/null
+++ b/scm/config_setup/api/shared_snippets_api.py
@@ -0,0 +1,883 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from scm.config_setup.models.snippet_share_load_payload import SnippetShareLoadPayload
+from scm.config_setup.models.snippet_share_upload_payload import SnippetShareUploadPayload
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SharedSnippetsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def convert_shared_snippets(
+ self,
+ snippet_share_upload_payload: Annotated[Optional[SnippetShareUploadPayload], Field(description="The `Shared Snippets To Update` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetShareInfo:
+ """Update Shared Snippets
+
+ Update Shared Snippets.
+
+ :param snippet_share_upload_payload: The `Shared Snippets To Update` resource definition
+ :type snippet_share_upload_payload: SnippetShareUploadPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._convert_shared_snippets_serialize(
+ snippet_share_upload_payload=snippet_share_upload_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetShareInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def convert_shared_snippets_with_http_info(
+ self,
+ snippet_share_upload_payload: Annotated[Optional[SnippetShareUploadPayload], Field(description="The `Shared Snippets To Update` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetShareInfo]:
+ """Update Shared Snippets
+
+ Update Shared Snippets.
+
+ :param snippet_share_upload_payload: The `Shared Snippets To Update` resource definition
+ :type snippet_share_upload_payload: SnippetShareUploadPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._convert_shared_snippets_serialize(
+ snippet_share_upload_payload=snippet_share_upload_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetShareInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def convert_shared_snippets_without_preload_content(
+ self,
+ snippet_share_upload_payload: Annotated[Optional[SnippetShareUploadPayload], Field(description="The `Shared Snippets To Update` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update Shared Snippets
+
+ Update Shared Snippets.
+
+ :param snippet_share_upload_payload: The `Shared Snippets To Update` resource definition
+ :type snippet_share_upload_payload: SnippetShareUploadPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._convert_shared_snippets_serialize(
+ snippet_share_upload_payload=snippet_share_upload_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetShareInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _convert_shared_snippets_serialize(
+ self,
+ snippet_share_upload_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippet_share_upload_payload is not None:
+ _body_params = snippet_share_upload_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/shared-snippets',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_shared_snippets(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[SnippetShareInfo]:
+ """Get Shared Snippets
+
+ Retrieve a list of shared snippets.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_shared_snippets_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetShareInfo]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_shared_snippets_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[SnippetShareInfo]]:
+ """Get Shared Snippets
+
+ Retrieve a list of shared snippets.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_shared_snippets_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetShareInfo]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_shared_snippets_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get Shared Snippets
+
+ Retrieve a list of shared snippets.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_shared_snippets_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetShareInfo]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_shared_snippets_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/shared-snippets',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def load_shared_snippets(
+ self,
+ snippet_share_load_payload: Annotated[Optional[SnippetShareLoadPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetShareLoadPayload:
+ """Load Shared Snippets
+
+ Convert Snippet Snippets.
+
+ :param snippet_share_load_payload: The `Snippet Snapshots To Convert` resource definition
+ :type snippet_share_load_payload: SnippetShareLoadPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_shared_snippets_serialize(
+ snippet_share_load_payload=snippet_share_load_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetShareLoadPayload",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def load_shared_snippets_with_http_info(
+ self,
+ snippet_share_load_payload: Annotated[Optional[SnippetShareLoadPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetShareLoadPayload]:
+ """Load Shared Snippets
+
+ Convert Snippet Snippets.
+
+ :param snippet_share_load_payload: The `Snippet Snapshots To Convert` resource definition
+ :type snippet_share_load_payload: SnippetShareLoadPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_shared_snippets_serialize(
+ snippet_share_load_payload=snippet_share_load_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetShareLoadPayload",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def load_shared_snippets_without_preload_content(
+ self,
+ snippet_share_load_payload: Annotated[Optional[SnippetShareLoadPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Load Shared Snippets
+
+ Convert Snippet Snippets.
+
+ :param snippet_share_load_payload: The `Snippet Snapshots To Convert` resource definition
+ :type snippet_share_load_payload: SnippetShareLoadPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_shared_snippets_serialize(
+ snippet_share_load_payload=snippet_share_load_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetShareLoadPayload",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _load_shared_snippets_serialize(
+ self,
+ snippet_share_load_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippet_share_load_payload is not None:
+ _body_params = snippet_share_load_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/shared-snippets:load',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/snippet_audit_logs_api.py b/scm/config_setup/api/snippet_audit_logs_api.py
new file mode 100644
index 00000000..f24c7523
--- /dev/null
+++ b/scm/config_setup/api/snippet_audit_logs_api.py
@@ -0,0 +1,625 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.snippet_audit_history import SnippetAuditHistory
+from scm.config_setup.models.snippet_audit_payload import SnippetAuditPayload
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SnippetAuditLogsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_snippet_audit_logs(
+ self,
+ snippet_audit_payload: Annotated[Optional[SnippetAuditPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetAuditHistory:
+ """Create snippet audit logs configuration
+
+ Create snippet audit logs configuration.
+
+ :param snippet_audit_payload: The `Snippet Snapshots To Convert` resource definition
+ :type snippet_audit_payload: SnippetAuditPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_snippet_audit_logs_serialize(
+ snippet_audit_payload=snippet_audit_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetAuditHistory",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_snippet_audit_logs_with_http_info(
+ self,
+ snippet_audit_payload: Annotated[Optional[SnippetAuditPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetAuditHistory]:
+ """Create snippet audit logs configuration
+
+ Create snippet audit logs configuration.
+
+ :param snippet_audit_payload: The `Snippet Snapshots To Convert` resource definition
+ :type snippet_audit_payload: SnippetAuditPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_snippet_audit_logs_serialize(
+ snippet_audit_payload=snippet_audit_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetAuditHistory",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_snippet_audit_logs_without_preload_content(
+ self,
+ snippet_audit_payload: Annotated[Optional[SnippetAuditPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create snippet audit logs configuration
+
+ Create snippet audit logs configuration.
+
+ :param snippet_audit_payload: The `Snippet Snapshots To Convert` resource definition
+ :type snippet_audit_payload: SnippetAuditPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_snippet_audit_logs_serialize(
+ snippet_audit_payload=snippet_audit_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetAuditHistory",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_snippet_audit_logs_serialize(
+ self,
+ snippet_audit_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippet_audit_payload is not None:
+ _body_params = snippet_audit_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-audit-logs',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_audit_logs_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetAuditHistory:
+ """Get a snippet audit logs
+
+ Retrieve an existing snippet audit logs by UUID.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_audit_logs_by_id_serialize(
+ id=id,
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetAuditHistory",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_audit_logs_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetAuditHistory]:
+ """Get a snippet audit logs
+
+ Retrieve an existing snippet audit logs by UUID.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_audit_logs_by_id_serialize(
+ id=id,
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetAuditHistory",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_audit_logs_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a snippet audit logs
+
+ Retrieve an existing snippet audit logs by UUID.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_audit_logs_by_id_serialize(
+ id=id,
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetAuditHistory",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_snippet_audit_logs_by_id_serialize(
+ self,
+ id,
+ type,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ if type is not None:
+
+ _query_params.append(('type', type))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/snippet-audit-logs/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/snippet_categories_api.py b/scm/config_setup/api/snippet_categories_api.py
new file mode 100644
index 00000000..ded3d9ff
--- /dev/null
+++ b/scm/config_setup/api/snippet_categories_api.py
@@ -0,0 +1,960 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.snippet_categories import SnippetCategories
+from scm.config_setup.models.snippet_categories_list_response import SnippetCategoriesListResponse
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SnippetCategoriesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def delete_snippet_category_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a snippet category
+
+ Delete an existing snippet category.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_snippet_category_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_snippet_category_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a snippet category
+
+ Delete an existing snippet category.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_snippet_category_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_snippet_category_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a snippet category
+
+ Delete an existing snippet category.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_snippet_category_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_snippet_category_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/snippet-categories/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_category_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetCategories:
+ """Get a snippet category
+
+ Retrieve an existing snippet category.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_category_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetCategories",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_category_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetCategories]:
+ """Get a snippet category
+
+ Retrieve an existing snippet category.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_category_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetCategories",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_category_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a snippet category
+
+ Retrieve an existing snippet category.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_category_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetCategories",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_snippet_category_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/snippet-categories/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_snippet_categories(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetCategoriesListResponse:
+ """List snippets categories
+
+ Retrieve a list of snippet categories.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_snippet_categories_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetCategoriesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_snippet_categories_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetCategoriesListResponse]:
+ """List snippets categories
+
+ Retrieve a list of snippet categories.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_snippet_categories_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetCategoriesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_snippet_categories_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List snippets categories
+
+ Retrieve a list of snippet categories.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_snippet_categories_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetCategoriesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_snippet_categories(
+ self,
+ name: str,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single snippet_categories object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name.
+
+ Args:
+ name: The name of the object to fetch
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_snippet_categories(name="my-object")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_snippet_categories(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _list_snippet_categories_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/snippet-categories',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/snippet_snapshots_api.py b/scm/config_setup/api/snippet_snapshots_api.py
new file mode 100644
index 00000000..705d9625
--- /dev/null
+++ b/scm/config_setup/api/snippet_snapshots_api.py
@@ -0,0 +1,2077 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import Any, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.common_snippet_snapshot_payload import CommonSnippetSnapshotPayload
+from scm.config_setup.models.compare_snippet_snapshot_config_payload import CompareSnippetSnapshotConfigPayload
+from scm.config_setup.models.compare_tlo_payload import CompareTloPayload
+from scm.config_setup.models.save_snippet_snapshot_config_response import SaveSnippetSnapshotConfigResponse
+from scm.config_setup.models.save_snippet_snapshot_payload import SaveSnippetSnapshotPayload
+from scm.config_setup.models.snippet_snapshot_compare_entry import SnippetSnapshotCompareEntry
+from scm.config_setup.models.snippet_snapshot_diff_response import SnippetSnapshotDiffResponse
+from scm.config_setup.models.snippet_snapshot_load_snippet_payload import SnippetSnapshotLoadSnippetPayload
+from scm.config_setup.models.snippet_snapshot_load_snippet_response import SnippetSnapshotLoadSnippetResponse
+from scm.config_setup.models.snippet_snapshot_publish_request import SnippetSnapshotPublishRequest
+from scm.config_setup.models.snippet_snapshot_publish_response import SnippetSnapshotPublishResponse
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_payload import SnippetSnapshotSubscriberComparePayload
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response import SnippetSnapshotSubscriberCompareResponse
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SnippetSnapshotsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def compare_snippet_snapshot(
+ self,
+ compare_snippet_snapshot_config_payload: Annotated[Optional[CompareSnippetSnapshotConfigPayload], Field(description="The `Snippet Snapshots To Compare` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[SnippetSnapshotCompareEntry]:
+ """Compare Snippet Snapshots
+
+ Compare Snippet Snapshots.
+
+ :param compare_snippet_snapshot_config_payload: The `Snippet Snapshots To Compare` resource definition
+ :type compare_snippet_snapshot_config_payload: CompareSnippetSnapshotConfigPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._compare_snippet_snapshot_serialize(
+ compare_snippet_snapshot_config_payload=compare_snippet_snapshot_config_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetSnapshotCompareEntry]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def compare_snippet_snapshot_with_http_info(
+ self,
+ compare_snippet_snapshot_config_payload: Annotated[Optional[CompareSnippetSnapshotConfigPayload], Field(description="The `Snippet Snapshots To Compare` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[SnippetSnapshotCompareEntry]]:
+ """Compare Snippet Snapshots
+
+ Compare Snippet Snapshots.
+
+ :param compare_snippet_snapshot_config_payload: The `Snippet Snapshots To Compare` resource definition
+ :type compare_snippet_snapshot_config_payload: CompareSnippetSnapshotConfigPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._compare_snippet_snapshot_serialize(
+ compare_snippet_snapshot_config_payload=compare_snippet_snapshot_config_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetSnapshotCompareEntry]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def compare_snippet_snapshot_without_preload_content(
+ self,
+ compare_snippet_snapshot_config_payload: Annotated[Optional[CompareSnippetSnapshotConfigPayload], Field(description="The `Snippet Snapshots To Compare` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Compare Snippet Snapshots
+
+ Compare Snippet Snapshots.
+
+ :param compare_snippet_snapshot_config_payload: The `Snippet Snapshots To Compare` resource definition
+ :type compare_snippet_snapshot_config_payload: CompareSnippetSnapshotConfigPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._compare_snippet_snapshot_serialize(
+ compare_snippet_snapshot_config_payload=compare_snippet_snapshot_config_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetSnapshotCompareEntry]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _compare_snippet_snapshot_serialize(
+ self,
+ compare_snippet_snapshot_config_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if compare_snippet_snapshot_config_payload is not None:
+ _body_params = compare_snippet_snapshot_config_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-snapshots:compare',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def convert_snippet_snapshot(
+ self,
+ common_snippet_snapshot_payload: Annotated[Optional[CommonSnippetSnapshotPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> object:
+ """Convert Snippet Snapshots
+
+ Convert Snippet Snapshots.
+
+ :param common_snippet_snapshot_payload: The `Snippet Snapshots To Convert` resource definition
+ :type common_snippet_snapshot_payload: CommonSnippetSnapshotPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._convert_snippet_snapshot_serialize(
+ common_snippet_snapshot_payload=common_snippet_snapshot_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "object",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def convert_snippet_snapshot_with_http_info(
+ self,
+ common_snippet_snapshot_payload: Annotated[Optional[CommonSnippetSnapshotPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[object]:
+ """Convert Snippet Snapshots
+
+ Convert Snippet Snapshots.
+
+ :param common_snippet_snapshot_payload: The `Snippet Snapshots To Convert` resource definition
+ :type common_snippet_snapshot_payload: CommonSnippetSnapshotPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._convert_snippet_snapshot_serialize(
+ common_snippet_snapshot_payload=common_snippet_snapshot_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "object",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def convert_snippet_snapshot_without_preload_content(
+ self,
+ common_snippet_snapshot_payload: Annotated[Optional[CommonSnippetSnapshotPayload], Field(description="The `Snippet Snapshots To Convert` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Convert Snippet Snapshots
+
+ Convert Snippet Snapshots.
+
+ :param common_snippet_snapshot_payload: The `Snippet Snapshots To Convert` resource definition
+ :type common_snippet_snapshot_payload: CommonSnippetSnapshotPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._convert_snippet_snapshot_serialize(
+ common_snippet_snapshot_payload=common_snippet_snapshot_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "object",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _convert_snippet_snapshot_serialize(
+ self,
+ common_snippet_snapshot_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if common_snippet_snapshot_payload is not None:
+ _body_params = common_snippet_snapshot_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-snapshots:convert',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def diff_snippet_snapshot(
+ self,
+ compare_tlo_payload: Annotated[Optional[CompareTloPayload], Field(description="The `Snippet Snapshots To Differentiate` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetSnapshotDiffResponse:
+ """Diff Snippet Snapshots
+
+ Diff Snippet Snapshots.
+
+ :param compare_tlo_payload: The `Snippet Snapshots To Differentiate` resource definition
+ :type compare_tlo_payload: CompareTloPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._diff_snippet_snapshot_serialize(
+ compare_tlo_payload=compare_tlo_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotDiffResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def diff_snippet_snapshot_with_http_info(
+ self,
+ compare_tlo_payload: Annotated[Optional[CompareTloPayload], Field(description="The `Snippet Snapshots To Differentiate` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetSnapshotDiffResponse]:
+ """Diff Snippet Snapshots
+
+ Diff Snippet Snapshots.
+
+ :param compare_tlo_payload: The `Snippet Snapshots To Differentiate` resource definition
+ :type compare_tlo_payload: CompareTloPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._diff_snippet_snapshot_serialize(
+ compare_tlo_payload=compare_tlo_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotDiffResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def diff_snippet_snapshot_without_preload_content(
+ self,
+ compare_tlo_payload: Annotated[Optional[CompareTloPayload], Field(description="The `Snippet Snapshots To Differentiate` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Diff Snippet Snapshots
+
+ Diff Snippet Snapshots.
+
+ :param compare_tlo_payload: The `Snippet Snapshots To Differentiate` resource definition
+ :type compare_tlo_payload: CompareTloPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._diff_snippet_snapshot_serialize(
+ compare_tlo_payload=compare_tlo_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotDiffResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _diff_snippet_snapshot_serialize(
+ self,
+ compare_tlo_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if compare_tlo_payload is not None:
+ _body_params = compare_tlo_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-snapshots:diff',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def load_snippet_snapshot(
+ self,
+ snippet_snapshot_load_snippet_payload: Annotated[Optional[SnippetSnapshotLoadSnippetPayload], Field(description="The `Snippet Snapshots To Load` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetSnapshotLoadSnippetResponse:
+ """Load Snippet Snapshots
+
+ Load Snippet Snapshots.
+
+ :param snippet_snapshot_load_snippet_payload: The `Snippet Snapshots To Load` resource definition
+ :type snippet_snapshot_load_snippet_payload: SnippetSnapshotLoadSnippetPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_snippet_snapshot_serialize(
+ snippet_snapshot_load_snippet_payload=snippet_snapshot_load_snippet_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotLoadSnippetResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def load_snippet_snapshot_with_http_info(
+ self,
+ snippet_snapshot_load_snippet_payload: Annotated[Optional[SnippetSnapshotLoadSnippetPayload], Field(description="The `Snippet Snapshots To Load` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetSnapshotLoadSnippetResponse]:
+ """Load Snippet Snapshots
+
+ Load Snippet Snapshots.
+
+ :param snippet_snapshot_load_snippet_payload: The `Snippet Snapshots To Load` resource definition
+ :type snippet_snapshot_load_snippet_payload: SnippetSnapshotLoadSnippetPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_snippet_snapshot_serialize(
+ snippet_snapshot_load_snippet_payload=snippet_snapshot_load_snippet_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotLoadSnippetResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def load_snippet_snapshot_without_preload_content(
+ self,
+ snippet_snapshot_load_snippet_payload: Annotated[Optional[SnippetSnapshotLoadSnippetPayload], Field(description="The `Snippet Snapshots To Load` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Load Snippet Snapshots
+
+ Load Snippet Snapshots.
+
+ :param snippet_snapshot_load_snippet_payload: The `Snippet Snapshots To Load` resource definition
+ :type snippet_snapshot_load_snippet_payload: SnippetSnapshotLoadSnippetPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._load_snippet_snapshot_serialize(
+ snippet_snapshot_load_snippet_payload=snippet_snapshot_load_snippet_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotLoadSnippetResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _load_snippet_snapshot_serialize(
+ self,
+ snippet_snapshot_load_snippet_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippet_snapshot_load_snippet_payload is not None:
+ _body_params = snippet_snapshot_load_snippet_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-snapshots:load',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def publish_snippet_snapshot(
+ self,
+ snippet_snapshot_publish_request: Annotated[Optional[SnippetSnapshotPublishRequest], Field(description="The `Snippet Snapshots To Publish` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetSnapshotPublishResponse:
+ """Publish Snippet Snapshots
+
+ Publish Snippet Snapshots.
+
+ :param snippet_snapshot_publish_request: The `Snippet Snapshots To Publish` resource definition
+ :type snippet_snapshot_publish_request: SnippetSnapshotPublishRequest
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._publish_snippet_snapshot_serialize(
+ snippet_snapshot_publish_request=snippet_snapshot_publish_request,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotPublishResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def publish_snippet_snapshot_with_http_info(
+ self,
+ snippet_snapshot_publish_request: Annotated[Optional[SnippetSnapshotPublishRequest], Field(description="The `Snippet Snapshots To Publish` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetSnapshotPublishResponse]:
+ """Publish Snippet Snapshots
+
+ Publish Snippet Snapshots.
+
+ :param snippet_snapshot_publish_request: The `Snippet Snapshots To Publish` resource definition
+ :type snippet_snapshot_publish_request: SnippetSnapshotPublishRequest
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._publish_snippet_snapshot_serialize(
+ snippet_snapshot_publish_request=snippet_snapshot_publish_request,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotPublishResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def publish_snippet_snapshot_without_preload_content(
+ self,
+ snippet_snapshot_publish_request: Annotated[Optional[SnippetSnapshotPublishRequest], Field(description="The `Snippet Snapshots To Publish` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Publish Snippet Snapshots
+
+ Publish Snippet Snapshots.
+
+ :param snippet_snapshot_publish_request: The `Snippet Snapshots To Publish` resource definition
+ :type snippet_snapshot_publish_request: SnippetSnapshotPublishRequest
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._publish_snippet_snapshot_serialize(
+ snippet_snapshot_publish_request=snippet_snapshot_publish_request,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotPublishResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _publish_snippet_snapshot_serialize(
+ self,
+ snippet_snapshot_publish_request,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippet_snapshot_publish_request is not None:
+ _body_params = snippet_snapshot_publish_request
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-snapshots:publish',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def save_snippet_snapshot(
+ self,
+ save_snippet_snapshot_payload: Annotated[Optional[SaveSnippetSnapshotPayload], Field(description="The `Save Snippet Snapshots` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SaveSnippetSnapshotConfigResponse:
+ """Save Snippet Snapshots
+
+ Save Snippet Snapshots.
+
+ :param save_snippet_snapshot_payload: The `Save Snippet Snapshots` resource definition
+ :type save_snippet_snapshot_payload: SaveSnippetSnapshotPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._save_snippet_snapshot_serialize(
+ save_snippet_snapshot_payload=save_snippet_snapshot_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SaveSnippetSnapshotConfigResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def save_snippet_snapshot_with_http_info(
+ self,
+ save_snippet_snapshot_payload: Annotated[Optional[SaveSnippetSnapshotPayload], Field(description="The `Save Snippet Snapshots` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SaveSnippetSnapshotConfigResponse]:
+ """Save Snippet Snapshots
+
+ Save Snippet Snapshots.
+
+ :param save_snippet_snapshot_payload: The `Save Snippet Snapshots` resource definition
+ :type save_snippet_snapshot_payload: SaveSnippetSnapshotPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._save_snippet_snapshot_serialize(
+ save_snippet_snapshot_payload=save_snippet_snapshot_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SaveSnippetSnapshotConfigResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def save_snippet_snapshot_without_preload_content(
+ self,
+ save_snippet_snapshot_payload: Annotated[Optional[SaveSnippetSnapshotPayload], Field(description="The `Save Snippet Snapshots` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Save Snippet Snapshots
+
+ Save Snippet Snapshots.
+
+ :param save_snippet_snapshot_payload: The `Save Snippet Snapshots` resource definition
+ :type save_snippet_snapshot_payload: SaveSnippetSnapshotPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._save_snippet_snapshot_serialize(
+ save_snippet_snapshot_payload=save_snippet_snapshot_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SaveSnippetSnapshotConfigResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _save_snippet_snapshot_serialize(
+ self,
+ save_snippet_snapshot_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if save_snippet_snapshot_payload is not None:
+ _body_params = save_snippet_snapshot_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-snapshots',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_snippet_snapshot(
+ self,
+ snippet_snapshot_subscriber_compare_payload: Annotated[Optional[SnippetSnapshotSubscriberComparePayload], Field(description="The `Snippet Snapshots To Update` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetSnapshotSubscriberCompareResponse:
+ """Update Snippet Snapshots
+
+ Update Snippet Snapshots.
+
+ :param snippet_snapshot_subscriber_compare_payload: The `Snippet Snapshots To Update` resource definition
+ :type snippet_snapshot_subscriber_compare_payload: SnippetSnapshotSubscriberComparePayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_snippet_snapshot_serialize(
+ snippet_snapshot_subscriber_compare_payload=snippet_snapshot_subscriber_compare_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotSubscriberCompareResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_snippet_snapshot_with_http_info(
+ self,
+ snippet_snapshot_subscriber_compare_payload: Annotated[Optional[SnippetSnapshotSubscriberComparePayload], Field(description="The `Snippet Snapshots To Update` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetSnapshotSubscriberCompareResponse]:
+ """Update Snippet Snapshots
+
+ Update Snippet Snapshots.
+
+ :param snippet_snapshot_subscriber_compare_payload: The `Snippet Snapshots To Update` resource definition
+ :type snippet_snapshot_subscriber_compare_payload: SnippetSnapshotSubscriberComparePayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_snippet_snapshot_serialize(
+ snippet_snapshot_subscriber_compare_payload=snippet_snapshot_subscriber_compare_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotSubscriberCompareResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_snippet_snapshot_without_preload_content(
+ self,
+ snippet_snapshot_subscriber_compare_payload: Annotated[Optional[SnippetSnapshotSubscriberComparePayload], Field(description="The `Snippet Snapshots To Update` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update Snippet Snapshots
+
+ Update Snippet Snapshots.
+
+ :param snippet_snapshot_subscriber_compare_payload: The `Snippet Snapshots To Update` resource definition
+ :type snippet_snapshot_subscriber_compare_payload: SnippetSnapshotSubscriberComparePayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_snippet_snapshot_serialize(
+ snippet_snapshot_subscriber_compare_payload=snippet_snapshot_subscriber_compare_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetSnapshotSubscriberCompareResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_snippet_snapshot_serialize(
+ self,
+ snippet_snapshot_subscriber_compare_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippet_snapshot_subscriber_compare_payload is not None:
+ _body_params = snippet_snapshot_subscriber_compare_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippet-snapshots:updates',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/snippets_api.py b/scm/config_setup/api/snippets_api.py
new file mode 100644
index 00000000..3d0afc63
--- /dev/null
+++ b/scm/config_setup/api/snippets_api.py
@@ -0,0 +1,1556 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.snippets import Snippets
+from scm.config_setup.models.snippets_list_response import SnippetsListResponse
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SnippetsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_snippet(
+ self,
+ snippets: Annotated[Optional[Snippets], Field(description="The `snippet` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Snippets:
+ """Create a snippet
+
+ Create a new snippet.
+
+ :param snippets: The `snippet` resource definition.
+ :type snippets: Snippets
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_snippet_serialize(
+ snippets=snippets,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_snippet_with_http_info(
+ self,
+ snippets: Annotated[Optional[Snippets], Field(description="The `snippet` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Snippets]:
+ """Create a snippet
+
+ Create a new snippet.
+
+ :param snippets: The `snippet` resource definition.
+ :type snippets: Snippets
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_snippet_serialize(
+ snippets=snippets,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_snippet_without_preload_content(
+ self,
+ snippets: Annotated[Optional[Snippets], Field(description="The `snippet` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a snippet
+
+ Create a new snippet.
+
+ :param snippets: The `snippet` resource definition.
+ :type snippets: Snippets
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_snippet_serialize(
+ snippets=snippets,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_snippet_serialize(
+ self,
+ snippets,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippets is not None:
+ _body_params = snippets
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/snippets',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_snippet_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a snippet
+
+ Delete an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_snippet_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_snippet_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a snippet
+
+ Delete an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_snippet_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_snippet_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a snippet
+
+ Delete an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_snippet_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_snippet_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/snippets/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Snippets:
+ """Get a snippet
+
+ Retrieve an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Snippets]:
+ """Get a snippet
+
+ Retrieve an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_snippet_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a snippet
+
+ Retrieve an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_snippet_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_snippet_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/snippets/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_snippets(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SnippetsListResponse:
+ """List snippets
+
+ Retrieve a list of snippets.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_snippets_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_snippets_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SnippetsListResponse]:
+ """List snippets
+
+ Retrieve a list of snippets.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_snippets_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_snippets_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List snippets
+
+ Retrieve a list of snippets.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_snippets_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SnippetsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_snippets_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/snippets',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_snippet_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ snippets: Annotated[Optional[Snippets], Field(description="The `snippet` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Snippets:
+ """Update a snippet
+
+ Update an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param snippets: The `snippet` resource definition.
+ :type snippets: Snippets
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_snippet_by_id_serialize(
+ id=id,
+ snippets=snippets,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_snippet_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ snippets: Annotated[Optional[Snippets], Field(description="The `snippet` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Snippets]:
+ """Update a snippet
+
+ Update an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param snippets: The `snippet` resource definition.
+ :type snippets: Snippets
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_snippet_by_id_serialize(
+ id=id,
+ snippets=snippets,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_snippet_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ snippets: Annotated[Optional[Snippets], Field(description="The `snippet` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a snippet
+
+ Update an existing snippet.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param snippets: The `snippet` resource definition.
+ :type snippets: Snippets
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_snippet_by_id_serialize(
+ id=id,
+ snippets=snippets,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Snippets",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_snippets(
+ self,
+ name: str,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single snippets object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name.
+
+ Args:
+ name: The name of the object to fetch
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_snippets(name="my-object")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_snippets(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_snippet_by_id_serialize(
+ self,
+ id,
+ snippets,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if snippets is not None:
+ _body_params = snippets
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/snippets/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/subscribed_tenants_api.py b/scm/config_setup/api/subscribed_tenants_api.py
new file mode 100644
index 00000000..6de9db2f
--- /dev/null
+++ b/scm/config_setup/api/subscribed_tenants_api.py
@@ -0,0 +1,1201 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.add_subscriber_request_payload_inner import AddSubscriberRequestPayloadInner
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from scm.config_setup.models.subscriber_property_payload import SubscriberPropertyPayload
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SubscribedTenantsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_subscribed_tenant(
+ self,
+ add_subscriber_request_payload_inner: Annotated[Optional[List[AddSubscriberRequestPayloadInner]], Field(description="The `Subscribed Tenant` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TenantTrustInfo:
+ """Create Subscribed Tenant
+
+ Create Subscribed Tenant.
+
+ :param add_subscriber_request_payload_inner: The `Subscribed Tenant` resource definition
+ :type add_subscriber_request_payload_inner: List[AddSubscriberRequestPayloadInner]
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_subscribed_tenant_serialize(
+ add_subscriber_request_payload_inner=add_subscriber_request_payload_inner,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_subscribed_tenant_with_http_info(
+ self,
+ add_subscriber_request_payload_inner: Annotated[Optional[List[AddSubscriberRequestPayloadInner]], Field(description="The `Subscribed Tenant` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TenantTrustInfo]:
+ """Create Subscribed Tenant
+
+ Create Subscribed Tenant.
+
+ :param add_subscriber_request_payload_inner: The `Subscribed Tenant` resource definition
+ :type add_subscriber_request_payload_inner: List[AddSubscriberRequestPayloadInner]
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_subscribed_tenant_serialize(
+ add_subscriber_request_payload_inner=add_subscriber_request_payload_inner,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_subscribed_tenant_without_preload_content(
+ self,
+ add_subscriber_request_payload_inner: Annotated[Optional[List[AddSubscriberRequestPayloadInner]], Field(description="The `Subscribed Tenant` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create Subscribed Tenant
+
+ Create Subscribed Tenant.
+
+ :param add_subscriber_request_payload_inner: The `Subscribed Tenant` resource definition
+ :type add_subscriber_request_payload_inner: List[AddSubscriberRequestPayloadInner]
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_subscribed_tenant_serialize(
+ add_subscriber_request_payload_inner=add_subscriber_request_payload_inner,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_subscribed_tenant_serialize(
+ self,
+ add_subscriber_request_payload_inner,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ 'AddSubscriberRequestPayloadInner': '',
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if add_subscriber_request_payload_inner is not None:
+ _body_params = add_subscriber_request_payload_inner
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/subscribed-tenants',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_subscribed_tenant_by_snipped_id(
+ self,
+ snippet_id: Annotated[StrictStr, Field(description="The ID of the snippet ")],
+ tsgs: Annotated[StrictStr, Field(description="Comma-separated list of recipient TSG IDs ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a subscribed tenant
+
+ Delete an existing subscribed tenant.
+
+ :param snippet_id: The ID of the snippet (required)
+ :type snippet_id: str
+ :param tsgs: Comma-separated list of recipient TSG IDs (required)
+ :type tsgs: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_subscribed_tenant_by_snipped_id_serialize(
+ snippet_id=snippet_id,
+ tsgs=tsgs,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_subscribed_tenant_by_snipped_id_with_http_info(
+ self,
+ snippet_id: Annotated[StrictStr, Field(description="The ID of the snippet ")],
+ tsgs: Annotated[StrictStr, Field(description="Comma-separated list of recipient TSG IDs ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a subscribed tenant
+
+ Delete an existing subscribed tenant.
+
+ :param snippet_id: The ID of the snippet (required)
+ :type snippet_id: str
+ :param tsgs: Comma-separated list of recipient TSG IDs (required)
+ :type tsgs: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_subscribed_tenant_by_snipped_id_serialize(
+ snippet_id=snippet_id,
+ tsgs=tsgs,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_subscribed_tenant_by_snipped_id_without_preload_content(
+ self,
+ snippet_id: Annotated[StrictStr, Field(description="The ID of the snippet ")],
+ tsgs: Annotated[StrictStr, Field(description="Comma-separated list of recipient TSG IDs ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a subscribed tenant
+
+ Delete an existing subscribed tenant.
+
+ :param snippet_id: The ID of the snippet (required)
+ :type snippet_id: str
+ :param tsgs: Comma-separated list of recipient TSG IDs (required)
+ :type tsgs: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_subscribed_tenant_by_snipped_id_serialize(
+ snippet_id=snippet_id,
+ tsgs=tsgs,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_subscribed_tenant_by_snipped_id_serialize(
+ self,
+ snippet_id,
+ tsgs,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if snippet_id is not None:
+
+ _query_params.append(('snippet-id', snippet_id))
+
+ if tsgs is not None:
+
+ _query_params.append(('tsgs', tsgs))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/subscribed-tenants',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_subscribed_tenants_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[SnippetShareInfo]:
+ """Get Subscribed Tenants
+
+ Retrieve a list of subscribed tenants.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_subscribed_tenants_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetShareInfo]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_subscribed_tenants_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[SnippetShareInfo]]:
+ """Get Subscribed Tenants
+
+ Retrieve a list of subscribed tenants.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_subscribed_tenants_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetShareInfo]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_subscribed_tenants_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get Subscribed Tenants
+
+ Retrieve a list of subscribed tenants.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_subscribed_tenants_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SnippetShareInfo]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_subscribed_tenants_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/subscribed-tenants/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_subscribed_tenant_by_snippet_id(
+ self,
+ subscriber_property_payload: Annotated[Optional[SubscriberPropertyPayload], Field(description="The `subscribed tenant` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SubscriberPropertyPayload:
+ """Update a subscribed tenant
+
+ Update an existing subscribed tenant.
+
+ :param subscriber_property_payload: The `subscribed tenant` resource definition.
+ :type subscriber_property_payload: SubscriberPropertyPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_subscribed_tenant_by_snippet_id_serialize(
+ subscriber_property_payload=subscriber_property_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SubscriberPropertyPayload",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_subscribed_tenant_by_snippet_id_with_http_info(
+ self,
+ subscriber_property_payload: Annotated[Optional[SubscriberPropertyPayload], Field(description="The `subscribed tenant` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SubscriberPropertyPayload]:
+ """Update a subscribed tenant
+
+ Update an existing subscribed tenant.
+
+ :param subscriber_property_payload: The `subscribed tenant` resource definition.
+ :type subscriber_property_payload: SubscriberPropertyPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_subscribed_tenant_by_snippet_id_serialize(
+ subscriber_property_payload=subscriber_property_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SubscriberPropertyPayload",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_subscribed_tenant_by_snippet_id_without_preload_content(
+ self,
+ subscriber_property_payload: Annotated[Optional[SubscriberPropertyPayload], Field(description="The `subscribed tenant` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a subscribed tenant
+
+ Update an existing subscribed tenant.
+
+ :param subscriber_property_payload: The `subscribed tenant` resource definition.
+ :type subscriber_property_payload: SubscriberPropertyPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_subscribed_tenant_by_snippet_id_serialize(
+ subscriber_property_payload=subscriber_property_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SubscriberPropertyPayload",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_subscribed_tenant_by_snippet_id_serialize(
+ self,
+ subscriber_property_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if subscriber_property_payload is not None:
+ _body_params = subscriber_property_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/subscribed-tenants',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/trust_information_api.py b/scm/config_setup/api/trust_information_api.py
new file mode 100644
index 00000000..23ce44ee
--- /dev/null
+++ b/scm/config_setup/api/trust_information_api.py
@@ -0,0 +1,320 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr, field_validator
+from typing import List
+from typing_extensions import Annotated
+from scm.config_setup.models.trust_info_with_shared_snippets import TrustInfoWithSharedSnippets
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TrustInformationApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def list_trusted_tenants_with_snippets(
+ self,
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[TrustInfoWithSharedSnippets]:
+ """Trusted Tenants With Snippets
+
+ Retrieve a list of trusted tenants with snippets.
+
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_trusted_tenants_with_snippets_serialize(
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[TrustInfoWithSharedSnippets]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_trusted_tenants_with_snippets_with_http_info(
+ self,
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[TrustInfoWithSharedSnippets]]:
+ """Trusted Tenants With Snippets
+
+ Retrieve a list of trusted tenants with snippets.
+
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_trusted_tenants_with_snippets_serialize(
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[TrustInfoWithSharedSnippets]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_trusted_tenants_with_snippets_without_preload_content(
+ self,
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Trusted Tenants With Snippets
+
+ Retrieve a list of trusted tenants with snippets.
+
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_trusted_tenants_with_snippets_serialize(
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[TrustInfoWithSharedSnippets]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_trusted_tenants_with_snippets_serialize(
+ self,
+ type,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if type is not None:
+
+ _query_params.append(('type', type))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/trusted-tenants',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/trust_validations_api.py b/scm/config_setup/api/trust_validations_api.py
new file mode 100644
index 00000000..b95bcad1
--- /dev/null
+++ b/scm/config_setup/api/trust_validations_api.py
@@ -0,0 +1,332 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+from scm.config_setup.models.trusts_validation_payload import TrustsValidationPayload
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TrustValidationsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def validate_trust(
+ self,
+ trusts_validation_payload: Annotated[Optional[TrustsValidationPayload], Field(description="The `trust validation` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TenantTrustInfo:
+ """Validates Trust
+
+ Validate trust.
+
+ :param trusts_validation_payload: The `trust validation` resource definition
+ :type trusts_validation_payload: TrustsValidationPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._validate_trust_serialize(
+ trusts_validation_payload=trusts_validation_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def validate_trust_with_http_info(
+ self,
+ trusts_validation_payload: Annotated[Optional[TrustsValidationPayload], Field(description="The `trust validation` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TenantTrustInfo]:
+ """Validates Trust
+
+ Validate trust.
+
+ :param trusts_validation_payload: The `trust validation` resource definition
+ :type trusts_validation_payload: TrustsValidationPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._validate_trust_serialize(
+ trusts_validation_payload=trusts_validation_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def validate_trust_without_preload_content(
+ self,
+ trusts_validation_payload: Annotated[Optional[TrustsValidationPayload], Field(description="The `trust validation` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Validates Trust
+
+ Validate trust.
+
+ :param trusts_validation_payload: The `trust validation` resource definition
+ :type trusts_validation_payload: TrustsValidationPayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._validate_trust_serialize(
+ trusts_validation_payload=trusts_validation_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _validate_trust_serialize(
+ self,
+ trusts_validation_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if trusts_validation_payload is not None:
+ _body_params = trusts_validation_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/trust-validations',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/trusted_tenants_overview_api.py b/scm/config_setup/api/trusted_tenants_overview_api.py
new file mode 100644
index 00000000..1e00fd1b
--- /dev/null
+++ b/scm/config_setup/api/trusted_tenants_overview_api.py
@@ -0,0 +1,300 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from scm.config_setup.models.trusted_tenant_overview import TrustedTenantOverview
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TrustedTenantsOverviewApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def get_trusted_tenants_overview(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TrustedTenantOverview:
+ """Trusted Tenants Overview
+
+ Overview of publishers and subscribers.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_trusted_tenants_overview_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrustedTenantOverview",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_trusted_tenants_overview_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TrustedTenantOverview]:
+ """Trusted Tenants Overview
+
+ Overview of publishers and subscribers.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_trusted_tenants_overview_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrustedTenantOverview",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_trusted_tenants_overview_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Trusted Tenants Overview
+
+ Overview of publishers and subscribers.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_trusted_tenants_overview_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrustedTenantOverview",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_trusted_tenants_overview_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/trusted-tenant-overview',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/trusts_api.py b/scm/config_setup/api/trusts_api.py
new file mode 100644
index 00000000..4cd5b592
--- /dev/null
+++ b/scm/config_setup/api/trusts_api.py
@@ -0,0 +1,630 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+from scm.config_setup.models.trusts import Trusts
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TrustsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_trust(
+ self,
+ trusts: Annotated[Optional[Trusts], Field(description="The `trusts` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TenantTrustInfo:
+ """Create a trust
+
+ Create a new trust.
+
+ :param trusts: The `trusts` resource definition
+ :type trusts: Trusts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_trust_serialize(
+ trusts=trusts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_trust_with_http_info(
+ self,
+ trusts: Annotated[Optional[Trusts], Field(description="The `trusts` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TenantTrustInfo]:
+ """Create a trust
+
+ Create a new trust.
+
+ :param trusts: The `trusts` resource definition
+ :type trusts: Trusts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_trust_serialize(
+ trusts=trusts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_trust_without_preload_content(
+ self,
+ trusts: Annotated[Optional[Trusts], Field(description="The `trusts` resource definition")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a trust
+
+ Create a new trust.
+
+ :param trusts: The `trusts` resource definition
+ :type trusts: Trusts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_trust_serialize(
+ trusts=trusts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TenantTrustInfo",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_trust_serialize(
+ self,
+ trusts,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if trusts is not None:
+ _body_params = trusts
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/trusts',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_trust(
+ self,
+ trustids: Annotated[StrictStr, Field(description="Comma-separated list of trust IDs ")],
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a Trust
+
+ Delete an existing Trust.
+
+ :param trustids: Comma-separated list of trust IDs (required)
+ :type trustids: str
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_trust_serialize(
+ trustids=trustids,
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_trust_with_http_info(
+ self,
+ trustids: Annotated[StrictStr, Field(description="Comma-separated list of trust IDs ")],
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a Trust
+
+ Delete an existing Trust.
+
+ :param trustids: Comma-separated list of trust IDs (required)
+ :type trustids: str
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_trust_serialize(
+ trustids=trustids,
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_trust_without_preload_content(
+ self,
+ trustids: Annotated[StrictStr, Field(description="Comma-separated list of trust IDs ")],
+ type: Annotated[StrictStr, Field(description="Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. ")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a Trust
+
+ Delete an existing Trust.
+
+ :param trustids: Comma-separated list of trust IDs (required)
+ :type trustids: str
+ :param type: Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. (required)
+ :type type: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_trust_serialize(
+ trustids=trustids,
+ type=type,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_trust_serialize(
+ self,
+ trustids,
+ type,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if trustids is not None:
+
+ _query_params.append(('trustids', trustids))
+
+ if type is not None:
+
+ _query_params.append(('type', type))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/trusts',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api/variables_api.py b/scm/config_setup/api/variables_api.py
new file mode 100644
index 00000000..f739cb36
--- /dev/null
+++ b/scm/config_setup/api/variables_api.py
@@ -0,0 +1,1670 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.config_setup.models.variables import Variables
+from scm.config_setup.models.variables_list_response import VariablesListResponse
+
+from scm.config_setup.api_client import ApiClient, RequestSerialized
+from scm.config_setup.api_response import ApiResponse
+from scm.config_setup.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class VariablesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_variable(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ variables: Annotated[Optional[Variables], Field(description="The `variable` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Variables:
+ """Create a variable
+
+ Create a new variable.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param variables: The `variable` resource definition.
+ :type variables: Variables
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_variable_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ variables=variables,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_variable_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ variables: Annotated[Optional[Variables], Field(description="The `variable` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Variables]:
+ """Create a variable
+
+ Create a new variable.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param variables: The `variable` resource definition.
+ :type variables: Variables
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_variable_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ variables=variables,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_variable_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ variables: Annotated[Optional[Variables], Field(description="The `variable` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a variable
+
+ Create a new variable.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param variables: The `variable` resource definition.
+ :type variables: Variables
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_variable_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ variables=variables,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_variable_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ variables,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if variables is not None:
+ _body_params = variables
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/variables',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_variable_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a variable
+
+ Delete an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_variable_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_variable_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a variable
+
+ Delete an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_variable_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_variable_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a variable
+
+ Delete an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_variable_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_variable_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/variables/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_variable_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Variables:
+ """Get a variables
+
+ Retrieve an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_variable_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_variable_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Variables]:
+ """Get a variables
+
+ Retrieve an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_variable_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_variable_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a variables
+
+ Retrieve an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_variable_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_variable_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/variables/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_variables(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VariablesListResponse:
+ """List variables
+
+ Retrieve a list of variables.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_variables_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VariablesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_variables_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VariablesListResponse]:
+ """List variables
+
+ Retrieve a list of variables.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_variables_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VariablesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_variables_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of resources to return")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of resources returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List variables
+
+ Retrieve a list of variables.
+
+ :param limit: The maximum number of resources to return
+ :type limit: int
+ :param offset: The offset into the list of resources returned
+ :type offset: int
+ :param name: The name of the resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_variables_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VariablesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_variables_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/variables',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_variable_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ variables: Annotated[Optional[Variables], Field(description="The `variable` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Variables:
+ """Update a variable
+
+ Update an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param variables: The `variable` resource definition.
+ :type variables: Variables
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_variable_by_id_serialize(
+ id=id,
+ variables=variables,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_variable_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ variables: Annotated[Optional[Variables], Field(description="The `variable` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Variables]:
+ """Update a variable
+
+ Update an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param variables: The `variable` resource definition.
+ :type variables: Variables
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_variable_by_id_serialize(
+ id=id,
+ variables=variables,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_variable_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the resource")],
+ variables: Annotated[Optional[Variables], Field(description="The `variable` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a variable
+
+ Update an existing variable.
+
+ :param id: The UUID of the resource (required)
+ :type id: str
+ :param variables: The `variable` resource definition.
+ :type variables: Variables
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_variable_by_id_serialize(
+ id=id,
+ variables=variables,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Variables",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_variables(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single variables object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_variables(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_variables(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_variable_by_id_serialize(
+ self,
+ id,
+ variables,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if variables is not None:
+ _body_params = variables
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/variables/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/config_setup/api_client.py b/scm/config_setup/api_client.py
new file mode 100644
index 00000000..64930419
--- /dev/null
+++ b/scm/config_setup/api_client.py
@@ -0,0 +1,798 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import datetime
+from dateutil.parser import parse
+from enum import Enum
+import decimal
+import json
+import mimetypes
+import os
+import re
+import tempfile
+
+from urllib.parse import quote
+from typing import Tuple, Optional, List, Dict, Union
+from pydantic import SecretStr
+
+from scm.config_setup.configuration import Configuration
+from scm.config_setup.api_response import ApiResponse, T as ApiResponseT
+import scm.config_setup.models
+from scm.config_setup import rest
+from scm.config_setup.exceptions import (
+ ApiValueError,
+ ApiException,
+ BadRequestException,
+ UnauthorizedException,
+ ForbiddenException,
+ NotFoundException,
+ ServiceException
+)
+
+RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]
+
+class ApiClient:
+ """Generic API client for OpenAPI client library builds.
+
+ OpenAPI generic API client. This client handles the client-
+ server communication, and is invariant across implementations. Specifics of
+ the methods and models for each application are generated from the OpenAPI
+ templates.
+
+ :param configuration: .Configuration object for this client
+ :param header_name: a header to pass when making calls to the API.
+ :param header_value: a header value to pass when making calls to
+ the API.
+ :param cookie: a cookie to include in the header when making calls
+ to the API
+ """
+
+ PRIMITIVE_TYPES = (float, bool, bytes, str, int)
+ NATIVE_TYPES_MAPPING = {
+ 'int': int,
+ 'long': int, # TODO remove as only py3 is supported?
+ 'float': float,
+ 'str': str,
+ 'bool': bool,
+ 'date': datetime.date,
+ 'datetime': datetime.datetime,
+ 'decimal': decimal.Decimal,
+ 'object': object,
+ }
+ _pool = None
+
+ def __init__(
+ self,
+ configuration=None,
+ header_name=None,
+ header_value=None,
+ cookie=None
+ ) -> None:
+ # use default configuration if none is provided
+ if configuration is None:
+ configuration = Configuration.get_default()
+ self.configuration = configuration
+
+ self.rest_client = rest.RESTClientObject(configuration)
+ self.default_headers = {}
+ if header_name is not None:
+ self.default_headers[header_name] = header_value
+ self.cookie = cookie
+ # Set default User-Agent.
+ self.user_agent = 'OpenAPI-Generator/1.0.0/python'
+ self.client_side_validation = configuration.client_side_validation
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ pass
+
+ @property
+ def user_agent(self):
+ """User agent for this API client"""
+ return self.default_headers['User-Agent']
+
+ @user_agent.setter
+ def user_agent(self, value):
+ self.default_headers['User-Agent'] = value
+
+ def set_default_header(self, header_name, header_value):
+ self.default_headers[header_name] = header_value
+
+
+ _default = None
+
+ @classmethod
+ def get_default(cls):
+ """Return new instance of ApiClient.
+
+ This method returns newly created, based on default constructor,
+ object of ApiClient class or returns a copy of default
+ ApiClient.
+
+ :return: The ApiClient object.
+ """
+ if cls._default is None:
+ cls._default = ApiClient()
+ return cls._default
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of ApiClient.
+
+ It stores default ApiClient.
+
+ :param default: object of ApiClient.
+ """
+ cls._default = default
+
+ def param_serialize(
+ self,
+ method,
+ resource_path,
+ path_params=None,
+ query_params=None,
+ header_params=None,
+ body=None,
+ post_params=None,
+ files=None, auth_settings=None,
+ collection_formats=None,
+ _host=None,
+ _request_auth=None
+ ) -> RequestSerialized:
+
+ """Builds the HTTP request params needed by the request.
+ :param method: Method to call.
+ :param resource_path: Path to method endpoint.
+ :param path_params: Path parameters in the url.
+ :param query_params: Query parameters in the url.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param auth_settings list: Auth Settings names for the request.
+ :param files dict: key -> filename, value -> filepath,
+ for `multipart/form-data`.
+ :param collection_formats: dict of collection formats for path, query,
+ header, and post parameters.
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the authentication
+ in the spec for a single request.
+ :return: tuple of form (path, http_method, query_params, header_params,
+ body, post_params, files)
+ """
+
+ config = self.configuration
+
+ # header parameters
+ header_params = header_params or {}
+ header_params.update(self.default_headers)
+ if self.cookie:
+ header_params['Cookie'] = self.cookie
+ if header_params:
+ header_params = self.sanitize_for_serialization(header_params)
+ header_params = dict(
+ self.parameters_to_tuples(header_params,collection_formats)
+ )
+
+ # path parameters
+ if path_params:
+ path_params = self.sanitize_for_serialization(path_params)
+ path_params = self.parameters_to_tuples(
+ path_params,
+ collection_formats
+ )
+ for k, v in path_params:
+ # specified safe chars, encode everything
+ resource_path = resource_path.replace(
+ '{%s}' % k,
+ quote(str(v), safe=config.safe_chars_for_path_param)
+ )
+
+ # post parameters
+ if post_params or files:
+ post_params = post_params if post_params else []
+ post_params = self.sanitize_for_serialization(post_params)
+ post_params = self.parameters_to_tuples(
+ post_params,
+ collection_formats
+ )
+ if files:
+ post_params.extend(self.files_parameters(files))
+
+ # auth setting
+ self.update_params_for_auth(
+ header_params,
+ query_params,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=_request_auth
+ )
+
+ # body
+ if body:
+ body = self.sanitize_for_serialization(body)
+
+ # request url
+ if _host is None or self.configuration.ignore_operation_servers:
+ url = self.configuration.host + resource_path
+ else:
+ # use server/host defined in path or operation instead
+ url = _host + resource_path
+
+ # query parameters
+ if query_params:
+ query_params = self.sanitize_for_serialization(query_params)
+ url_query = self.parameters_to_url_query(
+ query_params,
+ collection_formats
+ )
+ url += "?" + url_query
+
+ return method, url, header_params, body, post_params
+
+
+ def call_api(
+ self,
+ method,
+ url,
+ header_params=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ) -> rest.RESTResponse:
+ """Makes the HTTP request (synchronous)
+ :param method: Method to call.
+ :param url: Path to method endpoint.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param _request_timeout: timeout setting for this request.
+ :return: RESTResponse
+ """
+
+ try:
+ # perform request and return response
+ response_data = self.rest_client.request(
+ method, url,
+ headers=header_params,
+ body=body, post_params=post_params,
+ _request_timeout=_request_timeout
+ )
+
+ except ApiException as e:
+ raise e
+
+ return response_data
+
+ def response_deserialize(
+ self,
+ response_data: rest.RESTResponse,
+ response_types_map: Optional[Dict[str, ApiResponseT]]=None
+ ) -> ApiResponse[ApiResponseT]:
+ """Deserializes response into an object.
+ :param response_data: RESTResponse object to be deserialized.
+ :param response_types_map: dict of response types.
+ :return: ApiResponse
+ """
+
+ msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
+ assert response_data.data is not None, msg
+
+ response_type = response_types_map.get(str(response_data.status), None)
+ if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
+ # if not found, look for '1XX', '2XX', etc.
+ response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
+
+ # deserialize response data
+ response_text = None
+ return_data = None
+ try:
+ if response_type == "bytearray":
+ return_data = response_data.data
+ elif response_type == "file":
+ return_data = self.__deserialize_file(response_data)
+ elif response_type is not None:
+ match = None
+ content_type = response_data.getheader('content-type')
+ if content_type is not None:
+ match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
+ encoding = match.group(1) if match else "utf-8"
+ response_text = response_data.data.decode(encoding)
+ return_data = self.deserialize(response_text, response_type, content_type)
+ finally:
+ if not 200 <= response_data.status <= 299:
+ raise ApiException.from_response(
+ http_resp=response_data,
+ body=response_text,
+ data=return_data,
+ )
+
+ return ApiResponse(
+ status_code = response_data.status,
+ data = return_data,
+ headers = response_data.getheaders(),
+ raw_data = response_data.data
+ )
+
+ def sanitize_for_serialization(self, obj):
+ """Builds a JSON POST object.
+
+ If obj is None, return None.
+ If obj is SecretStr, return obj.get_secret_value()
+ If obj is str, int, long, float, bool, return directly.
+ If obj is datetime.datetime, datetime.date
+ convert to string in iso8601 format.
+ If obj is decimal.Decimal return string representation.
+ If obj is list, sanitize each element in the list.
+ If obj is dict, return the dict.
+ If obj is OpenAPI model, return the properties dict.
+
+ :param obj: The data to serialize.
+ :return: The serialized form of data.
+ """
+ if obj is None:
+ return None
+ elif isinstance(obj, Enum):
+ return obj.value
+ elif isinstance(obj, SecretStr):
+ return obj.get_secret_value()
+ elif isinstance(obj, self.PRIMITIVE_TYPES):
+ return obj
+ elif isinstance(obj, list):
+ return [
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ ]
+ elif isinstance(obj, tuple):
+ return tuple(
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ )
+ elif isinstance(obj, (datetime.datetime, datetime.date)):
+ return obj.isoformat()
+ elif isinstance(obj, decimal.Decimal):
+ return str(obj)
+
+ elif isinstance(obj, dict):
+ obj_dict = obj
+ else:
+ # Convert model obj to dict except
+ # attributes `openapi_types`, `attribute_map`
+ # and attributes which value is not None.
+ # Convert attribute name to json key in
+ # model definition for request.
+ if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
+ obj_dict = obj.to_dict()
+ else:
+ obj_dict = obj.__dict__
+
+ return {
+ key: self.sanitize_for_serialization(val)
+ for key, val in obj_dict.items()
+ }
+
+ def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]):
+ """Deserializes response into an object.
+
+ :param response: RESTResponse object to be deserialized.
+ :param response_type: class literal for
+ deserialized object, or string of class name.
+ :param content_type: content type of response.
+
+ :return: deserialized object.
+ """
+
+ # fetch data from response object
+ if content_type is None:
+ try:
+ data = json.loads(response_text)
+ except ValueError:
+ data = response_text
+ elif re.match(r'^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)', content_type, re.IGNORECASE):
+ if response_text == "":
+ data = ""
+ else:
+ data = json.loads(response_text)
+ elif re.match(r'^text\/[a-z.+-]+\s*(;|$)', content_type, re.IGNORECASE):
+ data = response_text
+ else:
+ raise ApiException(
+ status=0,
+ reason="Unsupported content type: {0}".format(content_type)
+ )
+
+ return self.__deserialize(data, response_type)
+
+ def __deserialize(self, data, klass):
+ """Deserializes dict, list, str into an object.
+
+ :param data: dict, list or str.
+ :param klass: class literal, or string of class name.
+
+ :return: object.
+ """
+ if data is None:
+ return None
+
+ if isinstance(klass, str):
+ if klass.startswith('List['):
+ m = re.match(r'List\[(.*)]', klass)
+ assert m is not None, "Malformed List type definition"
+ sub_kls = m.group(1)
+ return [self.__deserialize(sub_data, sub_kls)
+ for sub_data in data]
+
+ if klass.startswith('Dict['):
+ m = re.match(r'Dict\[([^,]*), (.*)]', klass)
+ assert m is not None, "Malformed Dict type definition"
+ sub_kls = m.group(2)
+ return {k: self.__deserialize(v, sub_kls)
+ for k, v in data.items()}
+
+ # convert str to class
+ if klass in self.NATIVE_TYPES_MAPPING:
+ klass = self.NATIVE_TYPES_MAPPING[klass]
+ else:
+ klass = getattr(scm.config_setup.models, klass)
+
+ if klass in self.PRIMITIVE_TYPES:
+ return self.__deserialize_primitive(data, klass)
+ elif klass == object:
+ return self.__deserialize_object(data)
+ elif klass == datetime.date:
+ return self.__deserialize_date(data)
+ elif klass == datetime.datetime:
+ return self.__deserialize_datetime(data)
+ elif klass == decimal.Decimal:
+ return decimal.Decimal(data)
+ elif issubclass(klass, Enum):
+ return self.__deserialize_enum(data, klass)
+ else:
+ return self.__deserialize_model(data, klass)
+
+ def parameters_to_tuples(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: Parameters as list of tuples, collections formatted
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, value) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(str(value) for value in v)))
+ else:
+ new_params.append((k, v))
+ return new_params
+
+ def parameters_to_url_query(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: URL query string (e.g. a=Hello%20World&b=123)
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if isinstance(v, bool):
+ v = str(v).lower()
+ if isinstance(v, (int, float)):
+ v = str(v)
+ if isinstance(v, dict):
+ v = json.dumps(v)
+
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, str(value)) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(quote(str(value)) for value in v))
+ )
+ else:
+ new_params.append((k, quote(str(v))))
+
+ return "&".join(["=".join(map(str, item)) for item in new_params])
+
+ def files_parameters(
+ self,
+ files: Dict[str, Union[str, bytes, List[str], List[bytes], Tuple[str, bytes]]],
+ ):
+ """Builds form parameters.
+
+ :param files: File parameters.
+ :return: Form parameters with files.
+ """
+ params = []
+ for k, v in files.items():
+ if isinstance(v, str):
+ with open(v, 'rb') as f:
+ filename = os.path.basename(f.name)
+ filedata = f.read()
+ elif isinstance(v, bytes):
+ filename = k
+ filedata = v
+ elif isinstance(v, tuple):
+ filename, filedata = v
+ elif isinstance(v, list):
+ for file_param in v:
+ params.extend(self.files_parameters({k: file_param}))
+ continue
+ else:
+ raise ValueError("Unsupported file value")
+ mimetype = (
+ mimetypes.guess_type(filename)[0]
+ or 'application/octet-stream'
+ )
+ params.append(
+ tuple([k, tuple([filename, filedata, mimetype])])
+ )
+ return params
+
+ def select_header_accept(self, accepts: List[str]) -> Optional[str]:
+ """Returns `Accept` based on an array of accepts provided.
+
+ :param accepts: List of headers.
+ :return: Accept (e.g. application/json).
+ """
+ if not accepts:
+ return None
+
+ for accept in accepts:
+ if re.search('json', accept, re.IGNORECASE):
+ return accept
+
+ return accepts[0]
+
+ def select_header_content_type(self, content_types):
+ """Returns `Content-Type` based on an array of content_types provided.
+
+ :param content_types: List of content-types.
+ :return: Content-Type (e.g. application/json).
+ """
+ if not content_types:
+ return None
+
+ for content_type in content_types:
+ if re.search('json', content_type, re.IGNORECASE):
+ return content_type
+
+ return content_types[0]
+
+ def update_params_for_auth(
+ self,
+ headers,
+ queries,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=None
+ ) -> None:
+ """Updates header and query params based on authentication setting.
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :param auth_settings: Authentication setting identifiers list.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param request_auth: if set, the provided settings will
+ override the token in the configuration.
+ """
+ if not auth_settings:
+ return
+
+ if request_auth:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ request_auth
+ )
+ else:
+ for auth in auth_settings:
+ auth_setting = self.configuration.auth_settings().get(auth)
+ if auth_setting:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ )
+
+ def _apply_auth_params(
+ self,
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ ) -> None:
+ """Updates the request parameters based on a single auth_setting
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param auth_setting: auth settings for the endpoint
+ """
+ if auth_setting['in'] == 'cookie':
+ headers['Cookie'] = auth_setting['value']
+ elif auth_setting['in'] == 'header':
+ if auth_setting['type'] != 'http-signature':
+ headers[auth_setting['key']] = auth_setting['value']
+ elif auth_setting['in'] == 'query':
+ queries.append((auth_setting['key'], auth_setting['value']))
+ else:
+ raise ApiValueError(
+ 'Authentication token must be in `query` or `header`'
+ )
+
+ def __deserialize_file(self, response):
+ """Deserializes body to file
+
+ Saves response body into a file in a temporary folder,
+ using the filename from the `Content-Disposition` header if provided.
+
+ handle file downloading
+ save response body into a tmp file and return the instance
+
+ :param response: RESTResponse.
+ :return: file path.
+ """
+ fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
+ os.close(fd)
+ os.remove(path)
+
+ content_disposition = response.getheader("Content-Disposition")
+ if content_disposition:
+ m = re.search(
+ r'filename=[\'"]?([^\'"\s]+)[\'"]?',
+ content_disposition
+ )
+ assert m is not None, "Unexpected 'content-disposition' header value"
+ filename = m.group(1)
+ path = os.path.join(os.path.dirname(path), filename)
+
+ with open(path, "wb") as f:
+ f.write(response.data)
+
+ return path
+
+ def __deserialize_primitive(self, data, klass):
+ """Deserializes string to primitive type.
+
+ :param data: str.
+ :param klass: class literal.
+
+ :return: int, long, float, str, bool.
+ """
+ try:
+ return klass(data)
+ except UnicodeEncodeError:
+ return str(data)
+ except TypeError:
+ return data
+
+ def __deserialize_object(self, value):
+ """Return an original value.
+
+ :return: object.
+ """
+ return value
+
+ def __deserialize_date(self, string):
+ """Deserializes string to date.
+
+ :param string: str.
+ :return: date.
+ """
+ try:
+ return parse(string).date()
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason="Failed to parse `{0}` as date object".format(string)
+ )
+
+ def __deserialize_datetime(self, string):
+ """Deserializes string to datetime.
+
+ The string should be in iso8601 datetime format.
+
+ :param string: str.
+ :return: datetime.
+ """
+ try:
+ return parse(string)
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as datetime object"
+ .format(string)
+ )
+ )
+
+ def __deserialize_enum(self, data, klass):
+ """Deserializes primitive type to enum.
+
+ :param data: primitive type.
+ :param klass: class literal.
+ :return: enum value.
+ """
+ try:
+ return klass(data)
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as `{1}`"
+ .format(data, klass)
+ )
+ )
+
+ def __deserialize_model(self, data, klass):
+ """Deserializes list or dict to model.
+
+ :param data: dict, list.
+ :param klass: class literal.
+ :return: model object.
+ """
+
+ return klass.from_dict(data)
diff --git a/scm/config_setup/api_response.py b/scm/config_setup/api_response.py
new file mode 100644
index 00000000..9bc7c11f
--- /dev/null
+++ b/scm/config_setup/api_response.py
@@ -0,0 +1,21 @@
+"""API response object."""
+
+from __future__ import annotations
+from typing import Optional, Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+ """
+ API response object
+ """
+
+ status_code: StrictInt = Field(description="HTTP status code")
+ headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
+ data: T = Field(description="Deserialized data given the data type")
+ raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
+
+ model_config = {
+ "arbitrary_types_allowed": True
+ }
diff --git a/scm/config_setup/configuration.py b/scm/config_setup/configuration.py
new file mode 100644
index 00000000..7d99b37c
--- /dev/null
+++ b/scm/config_setup/configuration.py
@@ -0,0 +1,467 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import copy
+import logging
+from logging import FileHandler
+import multiprocessing
+import sys
+from typing import Optional
+import urllib3
+
+import http.client as httplib
+
+JSON_SCHEMA_VALIDATION_KEYWORDS = {
+ 'multipleOf', 'maximum', 'exclusiveMaximum',
+ 'minimum', 'exclusiveMinimum', 'maxLength',
+ 'minLength', 'pattern', 'maxItems', 'minItems'
+}
+
+class Configuration:
+ """This class contains various settings of the API client.
+
+ :param host: Base url.
+ :param ignore_operation_servers
+ Boolean to ignore operation servers for the API client.
+ Config will use `host` as the base url regardless of the operation servers.
+ :param api_key: Dict to store API key(s).
+ Each entry in the dict specifies an API key.
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is the API key secret.
+ :param api_key_prefix: Dict to store API prefix (e.g. Bearer).
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is an API key prefix when generating the auth data.
+ :param username: Username for HTTP basic authentication.
+ :param password: Password for HTTP basic authentication.
+ :param access_token: Access token.
+ :param server_index: Index to servers configuration.
+ :param server_variables: Mapping with string values to replace variables in
+ templated server configuration. The validation of enums is performed for
+ variables with defined enum values before.
+ :param server_operation_index: Mapping from operation ID to an index to server
+ configuration.
+ :param server_operation_variables: Mapping from operation ID to a mapping with
+ string values to replace variables in templated server configuration.
+ The validation of enums is performed for variables with defined enum
+ values before.
+ :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
+ in PEM format.
+ :param retries: Number of retries for API requests.
+
+ :Example:
+ """
+
+ _default = None
+
+ def __init__(self, host=None,
+ api_key=None, api_key_prefix=None,
+ username=None, password=None,
+ access_token=None,
+ server_index=None, server_variables=None,
+ server_operation_index=None, server_operation_variables=None,
+ ignore_operation_servers=False,
+ ssl_ca_cert=None,
+ retries=None,
+ *,
+ debug: Optional[bool] = None
+ ) -> None:
+ """Constructor
+ """
+ self._base_path = "https://api.strata.paloaltonetworks.com/config/setup/v1" if host is None else host
+ """Default Base url
+ """
+ self.server_index = 0 if server_index is None and host is None else server_index
+ self.server_operation_index = server_operation_index or {}
+ """Default server index
+ """
+ self.server_variables = server_variables or {}
+ self.server_operation_variables = server_operation_variables or {}
+ """Default server variables
+ """
+ self.ignore_operation_servers = ignore_operation_servers
+ """Ignore operation servers
+ """
+ self.temp_folder_path = None
+ """Temp file folder for downloading files
+ """
+ # Authentication Settings
+ self.api_key = {}
+ if api_key:
+ self.api_key = api_key
+ """dict to store API key(s)
+ """
+ self.api_key_prefix = {}
+ if api_key_prefix:
+ self.api_key_prefix = api_key_prefix
+ """dict to store API prefix (e.g. Bearer)
+ """
+ self.refresh_api_key_hook = None
+ """function hook to refresh API key if expired
+ """
+ self.username = username
+ """Username for HTTP basic authentication
+ """
+ self.password = password
+ """Password for HTTP basic authentication
+ """
+ self.access_token = access_token
+ """Access token
+ """
+ self.logger = {}
+ """Logging Settings
+ """
+ self.logger["package_logger"] = logging.getLogger("scm.config_setup")
+ self.logger["urllib3_logger"] = logging.getLogger("urllib3")
+ self.logger_format = '%(asctime)s %(levelname)s %(message)s'
+ """Log format
+ """
+ self.logger_stream_handler = None
+ """Log stream handler
+ """
+ self.logger_file_handler: Optional[FileHandler] = None
+ """Log file handler
+ """
+ self.logger_file = None
+ """Debug file location
+ """
+ if debug is not None:
+ self.debug = debug
+ else:
+ self.__debug = False
+ """Debug switch
+ """
+
+ self.verify_ssl = True
+ """SSL/TLS verification
+ Set this to false to skip verifying SSL certificate when calling API
+ from https server.
+ """
+ self.ssl_ca_cert = ssl_ca_cert
+ """Set this to customize the certificate file to verify the peer.
+ """
+ self.cert_file = None
+ """client certificate file
+ """
+ self.key_file = None
+ """client key file
+ """
+ self.assert_hostname = None
+ """Set this to True/False to enable/disable SSL hostname verification.
+ """
+ self.tls_server_name = None
+ """SSL/TLS Server Name Indication (SNI)
+ Set this to the SNI value expected by the server.
+ """
+
+ self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
+ """urllib3 connection pool's maximum number of connections saved
+ per pool. urllib3 uses 1 connection as default value, but this is
+ not the best value when you are making a lot of possibly parallel
+ requests to the same host, which is often the case here.
+ cpu_count * 5 is used as default value to increase performance.
+ """
+
+ self.proxy: Optional[str] = None
+ """Proxy URL
+ """
+ self.proxy_headers = None
+ """Proxy headers
+ """
+ self.safe_chars_for_path_param = ''
+ """Safe chars for path_param
+ """
+ self.retries = retries
+ """Adding retries to override urllib3 default value 3
+ """
+ # Enable client side validation
+ self.client_side_validation = True
+
+ self.socket_options = None
+ """Options to pass down to the underlying urllib3 socket
+ """
+
+ self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z"
+ """datetime format
+ """
+
+ self.date_format = "%Y-%m-%d"
+ """date format
+ """
+
+ def __deepcopy__(self, memo):
+ cls = self.__class__
+ result = cls.__new__(cls)
+ memo[id(self)] = result
+ for k, v in self.__dict__.items():
+ if k not in ('logger', 'logger_file_handler'):
+ setattr(result, k, copy.deepcopy(v, memo))
+ # shallow copy of loggers
+ result.logger = copy.copy(self.logger)
+ # use setters to configure loggers
+ result.logger_file = self.logger_file
+ result.debug = self.debug
+ return result
+
+ def __setattr__(self, name, value):
+ object.__setattr__(self, name, value)
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of configuration.
+
+ It stores default configuration, which can be
+ returned by get_default_copy method.
+
+ :param default: object of Configuration
+ """
+ cls._default = default
+
+ @classmethod
+ def get_default_copy(cls):
+ """Deprecated. Please use `get_default` instead.
+
+ Deprecated. Please use `get_default` instead.
+
+ :return: The configuration object.
+ """
+ return cls.get_default()
+
+ @classmethod
+ def get_default(cls):
+ """Return the default configuration.
+
+ This method returns newly created, based on default constructor,
+ object of Configuration class or returns a copy of default
+ configuration.
+
+ :return: The configuration object.
+ """
+ if cls._default is None:
+ cls._default = Configuration()
+ return cls._default
+
+ @property
+ def logger_file(self):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ return self.__logger_file
+
+ @logger_file.setter
+ def logger_file(self, value):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ self.__logger_file = value
+ if self.__logger_file:
+ # If set logging file,
+ # then add file handler and remove stream handler.
+ self.logger_file_handler = logging.FileHandler(self.__logger_file)
+ self.logger_file_handler.setFormatter(self.logger_formatter)
+ for _, logger in self.logger.items():
+ logger.addHandler(self.logger_file_handler)
+
+ @property
+ def debug(self):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ return self.__debug
+
+ @debug.setter
+ def debug(self, value):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ self.__debug = value
+ if self.__debug:
+ # if debug status is True, turn on debug logging
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.DEBUG)
+ # turn on httplib debug
+ httplib.HTTPConnection.debuglevel = 1
+ else:
+ # if debug status is False, turn off debug logging,
+ # setting log level to default `logging.WARNING`
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.WARNING)
+ # turn off httplib debug
+ httplib.HTTPConnection.debuglevel = 0
+
+ @property
+ def logger_format(self):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ return self.__logger_format
+
+ @logger_format.setter
+ def logger_format(self, value):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ self.__logger_format = value
+ self.logger_formatter = logging.Formatter(self.__logger_format)
+
+ def get_api_key_with_prefix(self, identifier, alias=None):
+ """Gets API key (with prefix if set).
+
+ :param identifier: The identifier of apiKey.
+ :param alias: The alternative identifier of apiKey.
+ :return: The token for api key authentication.
+ """
+ if self.refresh_api_key_hook is not None:
+ self.refresh_api_key_hook(self)
+ key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
+ if key:
+ prefix = self.api_key_prefix.get(identifier)
+ if prefix:
+ return "%s %s" % (prefix, key)
+ else:
+ return key
+
+ def get_basic_auth_token(self):
+ """Gets HTTP basic authentication header (string).
+
+ :return: The token for basic HTTP authentication.
+ """
+ username = ""
+ if self.username is not None:
+ username = self.username
+ password = ""
+ if self.password is not None:
+ password = self.password
+ return urllib3.util.make_headers(
+ basic_auth=username + ':' + password
+ ).get('authorization')
+
+ def auth_settings(self):
+ """Gets Auth Settings dict for api client.
+
+ :return: The Auth Settings information dict.
+ """
+ auth = {}
+ if self.access_token is not None:
+ auth['scmOAuth'] = {
+ 'type': 'oauth2',
+ 'in': 'header',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ if self.access_token is not None:
+ auth['scmToken'] = {
+ 'type': 'bearer',
+ 'in': 'header',
+ 'format': 'JWT',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ return auth
+
+ def to_debug_report(self):
+ """Gets the essential information for debugging.
+
+ :return: The report for debugging.
+ """
+ return "Python SDK Debug Report:\n"\
+ "OS: {env}\n"\
+ "Python Version: {pyversion}\n"\
+ "Version of the API: 2.0.0\n"\
+ "SDK Package Version: 1.0.0".\
+ format(env=sys.platform, pyversion=sys.version)
+
+ def get_host_settings(self):
+ """Gets an array of host settings
+
+ :return: An array of host settings
+ """
+ return [
+ {
+ 'url': "https://api.strata.paloaltonetworks.com/config/setup/v1",
+ 'description': "Current",
+ }
+ ]
+
+ def get_host_from_settings(self, index, variables=None, servers=None):
+ """Gets host URL based on the index and variables
+ :param index: array index of the host settings
+ :param variables: hash of variable and the corresponding value
+ :param servers: an array of host settings or None
+ :return: URL based on host settings
+ """
+ if index is None:
+ return self._base_path
+
+ variables = {} if variables is None else variables
+ servers = self.get_host_settings() if servers is None else servers
+
+ try:
+ server = servers[index]
+ except IndexError:
+ raise ValueError(
+ "Invalid index {0} when selecting the host settings. "
+ "Must be less than {1}".format(index, len(servers)))
+
+ url = server['url']
+
+ # go through variables and replace placeholders
+ for variable_name, variable in server.get('variables', {}).items():
+ used_value = variables.get(
+ variable_name, variable['default_value'])
+
+ if 'enum_values' in variable \
+ and used_value not in variable['enum_values']:
+ raise ValueError(
+ "The variable `{0}` in the host URL has invalid value "
+ "{1}. Must be {2}.".format(
+ variable_name, variables[variable_name],
+ variable['enum_values']))
+
+ url = url.replace("{" + variable_name + "}", used_value)
+
+ return url
+
+ @property
+ def host(self):
+ """Return generated host."""
+ return self.get_host_from_settings(self.server_index, variables=self.server_variables)
+
+ @host.setter
+ def host(self, value):
+ """Fix base path."""
+ self._base_path = value
+ self.server_index = None
diff --git a/scm/config_setup/docs/AddSubscriberRequestPayloadInner.md b/scm/config_setup/docs/AddSubscriberRequestPayloadInner.md
new file mode 100644
index 00000000..67bff8d7
--- /dev/null
+++ b/scm/config_setup/docs/AddSubscriberRequestPayloadInner.md
@@ -0,0 +1,31 @@
+# AddSubscriberRequestPayloadInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**snippet_id** | **str** | |
+**snippet_name** | **str** | |
+**tsg_id** | **str** | |
+
+## Example
+
+```python
+from scm.config_setup.models.add_subscriber_request_payload_inner import AddSubscriberRequestPayloadInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AddSubscriberRequestPayloadInner from a JSON string
+add_subscriber_request_payload_inner_instance = AddSubscriberRequestPayloadInner.from_json(json)
+# print the JSON string representation of the object
+print(AddSubscriberRequestPayloadInner.to_json())
+
+# convert the object into a dict
+add_subscriber_request_payload_inner_dict = add_subscriber_request_payload_inner_instance.to_dict()
+# create an instance of AddSubscriberRequestPayloadInner from a dict
+add_subscriber_request_payload_inner_from_dict = AddSubscriberRequestPayloadInner.from_dict(add_subscriber_request_payload_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/CommonSnippetSnapshotPayload.md b/scm/config_setup/docs/CommonSnippetSnapshotPayload.md
new file mode 100644
index 00000000..eb33819b
--- /dev/null
+++ b/scm/config_setup/docs/CommonSnippetSnapshotPayload.md
@@ -0,0 +1,30 @@
+# CommonSnippetSnapshotPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | | [optional]
+**keep_local** | **bool** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.common_snippet_snapshot_payload import CommonSnippetSnapshotPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CommonSnippetSnapshotPayload from a JSON string
+common_snippet_snapshot_payload_instance = CommonSnippetSnapshotPayload.from_json(json)
+# print the JSON string representation of the object
+print(CommonSnippetSnapshotPayload.to_json())
+
+# convert the object into a dict
+common_snippet_snapshot_payload_dict = common_snippet_snapshot_payload_instance.to_dict()
+# create an instance of CommonSnippetSnapshotPayload from a dict
+common_snippet_snapshot_payload_from_dict = CommonSnippetSnapshotPayload.from_dict(common_snippet_snapshot_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/CompareSnippetSnapshotConfigPayload.md b/scm/config_setup/docs/CompareSnippetSnapshotConfigPayload.md
new file mode 100644
index 00000000..69afee94
--- /dev/null
+++ b/scm/config_setup/docs/CompareSnippetSnapshotConfigPayload.md
@@ -0,0 +1,31 @@
+# CompareSnippetSnapshotConfigPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**comparing_version** | **int** | |
+**id** | **str** | |
+**version** | **int** | |
+
+## Example
+
+```python
+from scm.config_setup.models.compare_snippet_snapshot_config_payload import CompareSnippetSnapshotConfigPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CompareSnippetSnapshotConfigPayload from a JSON string
+compare_snippet_snapshot_config_payload_instance = CompareSnippetSnapshotConfigPayload.from_json(json)
+# print the JSON string representation of the object
+print(CompareSnippetSnapshotConfigPayload.to_json())
+
+# convert the object into a dict
+compare_snippet_snapshot_config_payload_dict = compare_snippet_snapshot_config_payload_instance.to_dict()
+# create an instance of CompareSnippetSnapshotConfigPayload from a dict
+compare_snippet_snapshot_config_payload_from_dict = CompareSnippetSnapshotConfigPayload.from_dict(compare_snippet_snapshot_config_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/CompareTloPayload.md b/scm/config_setup/docs/CompareTloPayload.md
new file mode 100644
index 00000000..2147c95a
--- /dev/null
+++ b/scm/config_setup/docs/CompareTloPayload.md
@@ -0,0 +1,32 @@
+# CompareTloPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**comparing_version** | **int** | | [optional]
+**object_id** | **str** | |
+**snippet_id** | **str** | |
+**version** | **int** | |
+
+## Example
+
+```python
+from scm.config_setup.models.compare_tlo_payload import CompareTloPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CompareTloPayload from a JSON string
+compare_tlo_payload_instance = CompareTloPayload.from_json(json)
+# print the JSON string representation of the object
+print(CompareTloPayload.to_json())
+
+# convert the object into a dict
+compare_tlo_payload_dict = compare_tlo_payload_instance.to_dict()
+# create an instance of CompareTloPayload from a dict
+compare_tlo_payload_from_dict = CompareTloPayload.from_dict(compare_tlo_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/DeletedSubscriber.md b/scm/config_setup/docs/DeletedSubscriber.md
new file mode 100644
index 00000000..b2c6b3ad
--- /dev/null
+++ b/scm/config_setup/docs/DeletedSubscriber.md
@@ -0,0 +1,31 @@
+# DeletedSubscriber
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**details** | **str** | | [optional]
+**info** | [**SnippetShareInfo**](SnippetShareInfo.md) | | [optional]
+**status** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.deleted_subscriber import DeletedSubscriber
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of DeletedSubscriber from a JSON string
+deleted_subscriber_instance = DeletedSubscriber.from_json(json)
+# print the JSON string representation of the object
+print(DeletedSubscriber.to_json())
+
+# convert the object into a dict
+deleted_subscriber_dict = deleted_subscriber_instance.to_dict()
+# create an instance of DeletedSubscriber from a dict
+deleted_subscriber_from_dict = DeletedSubscriber.from_dict(deleted_subscriber_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/Devices.md b/scm/config_setup/docs/Devices.md
new file mode 100644
index 00000000..d6f26619
--- /dev/null
+++ b/scm/config_setup/docs/Devices.md
@@ -0,0 +1,69 @@
+# Devices
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**anti_virus_version** | **str** | | [optional] [readonly]
+**app_release_date** | **str** | | [optional] [readonly]
+**app_version** | **str** | | [optional] [readonly]
+**av_release_date** | **str** | | [optional] [readonly]
+**available_licensess** | [**List[DevicesAvailableLicensessInner]**](DevicesAvailableLicensessInner.md) | | [optional] [readonly]
+**connected_since** | **datetime** | | [optional] [readonly]
+**description** | **str** | The description of the device | [optional]
+**dev_cert_detail** | **str** | | [optional] [readonly]
+**dev_cert_expiry_date** | **str** | | [optional] [readonly]
+**display_name** | **str** | The display name of the device | [optional]
+**family** | **str** | The product family of the device | [optional] [readonly]
+**folder** | **str** | The folder containing the device |
+**gp_client_verion** | **str** | | [optional] [readonly]
+**gp_data_version** | **str** | | [optional] [readonly]
+**ha_peer_serial** | **str** | | [optional] [readonly]
+**ha_peer_state** | **str** | | [optional] [readonly]
+**ha_state** | **str** | | [optional] [readonly]
+**hostname** | **str** | The hostname of the device | [optional] [readonly]
+**id** | **str** | The UUID of the device | [readonly]
+**installed_licenses** | [**List[DevicesInstalledLicensesInner]**](DevicesInstalledLicensesInner.md) | | [optional] [readonly]
+**iot_release_date** | **str** | | [optional] [readonly]
+**iot_version** | **str** | | [optional] [readonly]
+**ip_v6_address** | **str** | The IPv6 address of the device | [optional] [readonly]
+**ip_address** | **str** | The IPv4 address of the device | [optional] [readonly]
+**is_connected** | **bool** | | [optional] [readonly]
+**labels** | **List[str]** | Labels assigned to the device | [optional]
+**license_match** | **bool** | | [optional] [readonly]
+**log_db_version** | **str** | | [optional] [readonly]
+**mac_address** | **str** | The MAC address of the device | [optional] [readonly]
+**model** | **str** | The model of the device | [optional] [readonly]
+**name** | **str** | The name of the device |
+**snippets** | **List[str]** | Snippets associated with the device | [optional]
+**software_version** | **str** | | [optional] [readonly]
+**threat_release_date** | **str** | | [optional] [readonly]
+**threat_version** | **str** | | [optional] [readonly]
+**uptime** | **str** | | [optional] [readonly]
+**url_db_type** | **str** | | [optional] [readonly]
+**url_db_ver** | **str** | | [optional] [readonly]
+**vm_state** | **str** | | [optional] [readonly]
+**wf_release_date** | **str** | | [optional] [readonly]
+**wf_ver** | **str** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.devices import Devices
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Devices from a JSON string
+devices_instance = Devices.from_json(json)
+# print the JSON string representation of the object
+print(Devices.to_json())
+
+# convert the object into a dict
+devices_dict = devices_instance.to_dict()
+# create an instance of Devices from a dict
+devices_from_dict = Devices.from_dict(devices_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/DevicesAvailableLicensessInner.md b/scm/config_setup/docs/DevicesAvailableLicensessInner.md
new file mode 100644
index 00000000..c0bbc0d6
--- /dev/null
+++ b/scm/config_setup/docs/DevicesAvailableLicensessInner.md
@@ -0,0 +1,32 @@
+# DevicesAvailableLicensessInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authcode** | **str** | | [optional] [readonly]
+**expires** | **date** | | [optional] [readonly]
+**feature** | **str** | | [optional] [readonly]
+**issued** | **date** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.devices_available_licensess_inner import DevicesAvailableLicensessInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of DevicesAvailableLicensessInner from a JSON string
+devices_available_licensess_inner_instance = DevicesAvailableLicensessInner.from_json(json)
+# print the JSON string representation of the object
+print(DevicesAvailableLicensessInner.to_json())
+
+# convert the object into a dict
+devices_available_licensess_inner_dict = devices_available_licensess_inner_instance.to_dict()
+# create an instance of DevicesAvailableLicensessInner from a dict
+devices_available_licensess_inner_from_dict = DevicesAvailableLicensessInner.from_dict(devices_available_licensess_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/DevicesInstalledLicensesInner.md b/scm/config_setup/docs/DevicesInstalledLicensesInner.md
new file mode 100644
index 00000000..31397931
--- /dev/null
+++ b/scm/config_setup/docs/DevicesInstalledLicensesInner.md
@@ -0,0 +1,33 @@
+# DevicesInstalledLicensesInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authcode** | **str** | | [optional] [readonly]
+**expired** | **str** | | [optional] [readonly]
+**expires** | **str** | | [optional] [readonly]
+**feature** | **str** | | [optional] [readonly]
+**issued** | **date** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.devices_installed_licenses_inner import DevicesInstalledLicensesInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of DevicesInstalledLicensesInner from a JSON string
+devices_installed_licenses_inner_instance = DevicesInstalledLicensesInner.from_json(json)
+# print the JSON string representation of the object
+print(DevicesInstalledLicensesInner.to_json())
+
+# convert the object into a dict
+devices_installed_licenses_inner_dict = devices_installed_licenses_inner_instance.to_dict()
+# create an instance of DevicesInstalledLicensesInner from a dict
+devices_installed_licenses_inner_from_dict = DevicesInstalledLicensesInner.from_dict(devices_installed_licenses_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/DevicesPut.md b/scm/config_setup/docs/DevicesPut.md
new file mode 100644
index 00000000..c6a1f353
--- /dev/null
+++ b/scm/config_setup/docs/DevicesPut.md
@@ -0,0 +1,33 @@
+# DevicesPut
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | The description of the device | [optional]
+**display_name** | **str** | The display name of the device | [optional]
+**folder** | **str** | The folder containing the device | [optional]
+**labels** | **List[str]** | Labels assigned to the device | [optional]
+**snippets** | **List[str]** | Snippets associated with the device | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.devices_put import DevicesPut
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of DevicesPut from a JSON string
+devices_put_instance = DevicesPut.from_json(json)
+# print the JSON string representation of the object
+print(DevicesPut.to_json())
+
+# convert the object into a dict
+devices_put_dict = devices_put_instance.to_dict()
+# create an instance of DevicesPut from a dict
+devices_put_from_dict = DevicesPut.from_dict(devices_put_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/ErrorDetailCauseInfo.md b/scm/config_setup/docs/ErrorDetailCauseInfo.md
new file mode 100644
index 00000000..d75025cd
--- /dev/null
+++ b/scm/config_setup/docs/ErrorDetailCauseInfo.md
@@ -0,0 +1,32 @@
+# ErrorDetailCauseInfo
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **str** | | [optional]
+**details** | **object** | | [optional]
+**help** | **str** | | [optional]
+**message** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.error_detail_cause_info import ErrorDetailCauseInfo
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ErrorDetailCauseInfo from a JSON string
+error_detail_cause_info_instance = ErrorDetailCauseInfo.from_json(json)
+# print the JSON string representation of the object
+print(ErrorDetailCauseInfo.to_json())
+
+# convert the object into a dict
+error_detail_cause_info_dict = error_detail_cause_info_instance.to_dict()
+# create an instance of ErrorDetailCauseInfo from a dict
+error_detail_cause_info_from_dict = ErrorDetailCauseInfo.from_dict(error_detail_cause_info_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/Folders.md b/scm/config_setup/docs/Folders.md
new file mode 100644
index 00000000..6aa58499
--- /dev/null
+++ b/scm/config_setup/docs/Folders.md
@@ -0,0 +1,34 @@
+# Folders
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | The description of the folder | [optional]
+**id** | **str** | The UUID of the folder | [optional] [readonly]
+**labels** | **List[str]** | Labels assigned to the folder | [optional]
+**name** | **str** | The name of the folder |
+**parent** | **str** | The parent folder |
+**snippets** | **List[str]** | Snippets associated with the folder | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.folders import Folders
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Folders from a JSON string
+folders_instance = Folders.from_json(json)
+# print the JSON string representation of the object
+print(Folders.to_json())
+
+# convert the object into a dict
+folders_dict = folders_instance.to_dict()
+# create an instance of Folders from a dict
+folders_from_dict = Folders.from_dict(folders_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/FoldersApi.md b/scm/config_setup/docs/FoldersApi.md
new file mode 100644
index 00000000..daa96009
--- /dev/null
+++ b/scm/config_setup/docs/FoldersApi.md
@@ -0,0 +1,433 @@
+# scm.config_setup.FoldersApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_folder**](FoldersApi.md#create_folder) | **POST** /folders | Create a folder
+[**delete_folder_by_id**](FoldersApi.md#delete_folder_by_id) | **DELETE** /folders/{id} | Delete a folder
+[**get_folder_by_id**](FoldersApi.md#get_folder_by_id) | **GET** /folders/{id} | Get a folder
+[**list_folders**](FoldersApi.md#list_folders) | **GET** /folders | List folders
+[**update_folder_by_id**](FoldersApi.md#update_folder_by_id) | **PUT** /folders/{id} | Update a folder
+
+
+# **create_folder**
+> Folders create_folder(folders=folders)
+
+Create a folder
+
+Create a new folder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.folders import Folders
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.FoldersApi(api_client)
+ folders = scm.config_setup.Folders() # Folders | The `folder` resource definition (optional)
+
+ try:
+ # Create a folder
+ api_response = api_instance.create_folder(folders=folders)
+ print("The response of FoldersApi->create_folder:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling FoldersApi->create_folder: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folders** | [**Folders**](Folders.md)| The `folder` resource definition | [optional]
+
+### Return type
+
+[**Folders**](Folders.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_folder_by_id**
+> delete_folder_by_id(id)
+
+Delete a folder
+
+Delete an existing folder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.FoldersApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Delete a folder
+ api_instance.delete_folder_by_id(id)
+ except Exception as e:
+ print("Exception when calling FoldersApi->delete_folder_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_folder_by_id**
+> Folders get_folder_by_id(id)
+
+Get a folder
+
+Retrieve an existing folder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.folders import Folders
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.FoldersApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Get a folder
+ api_response = api_instance.get_folder_by_id(id)
+ print("The response of FoldersApi->get_folder_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling FoldersApi->get_folder_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+[**Folders**](Folders.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_folders**
+> FoldersListResponse list_folders(limit=limit, offset=offset, name=name)
+
+List folders
+
+Retrieve a list of folders.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.folders_list_response import FoldersListResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.FoldersApi(api_client)
+ limit = 56 # int | The maximum number of resources to return (optional)
+ offset = 56 # int | The offset into the list of resources returned (optional)
+ name = 'name_example' # str | The name of the resource (optional)
+
+ try:
+ # List folders
+ api_response = api_instance.list_folders(limit=limit, offset=offset, name=name)
+ print("The response of FoldersApi->list_folders:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling FoldersApi->list_folders: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of resources to return | [optional]
+ **offset** | **int**| The offset into the list of resources returned | [optional]
+ **name** | **str**| The name of the resource | [optional]
+
+### Return type
+
+[**FoldersListResponse**](FoldersListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_folder_by_id**
+> Folders update_folder_by_id(id, folders=folders)
+
+Update a folder
+
+Update an existing folder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.folders import Folders
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.FoldersApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+ folders = scm.config_setup.Folders() # Folders | The `folder` resource definition. (optional)
+
+ try:
+ # Update a folder
+ api_response = api_instance.update_folder_by_id(id, folders=folders)
+ print("The response of FoldersApi->update_folder_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling FoldersApi->update_folder_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+ **folders** | [**Folders**](Folders.md)| The `folder` resource definition. | [optional]
+
+### Return type
+
+[**Folders**](Folders.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/FoldersListResponse.md b/scm/config_setup/docs/FoldersListResponse.md
new file mode 100644
index 00000000..2ceff8cf
--- /dev/null
+++ b/scm/config_setup/docs/FoldersListResponse.md
@@ -0,0 +1,32 @@
+# FoldersListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[Folders]**](Folders.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.config_setup.models.folders_list_response import FoldersListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of FoldersListResponse from a JSON string
+folders_list_response_instance = FoldersListResponse.from_json(json)
+# print the JSON string representation of the object
+print(FoldersListResponse.to_json())
+
+# convert the object into a dict
+folders_list_response_dict = folders_list_response_instance.to_dict()
+# create an instance of FoldersListResponse from a dict
+folders_list_response_from_dict = FoldersListResponse.from_dict(folders_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/GenericError.md b/scm/config_setup/docs/GenericError.md
new file mode 100644
index 00000000..b6ca76f5
--- /dev/null
+++ b/scm/config_setup/docs/GenericError.md
@@ -0,0 +1,30 @@
+# GenericError
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**errors** | [**List[ErrorDetailCauseInfo]**](ErrorDetailCauseInfo.md) | | [optional]
+**request_id** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.generic_error import GenericError
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GenericError from a JSON string
+generic_error_instance = GenericError.from_json(json)
+# print the JSON string representation of the object
+print(GenericError.to_json())
+
+# convert the object into a dict
+generic_error_dict = generic_error_instance.to_dict()
+# create an instance of GenericError from a dict
+generic_error_from_dict = GenericError.from_dict(generic_error_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/Labels.md b/scm/config_setup/docs/Labels.md
new file mode 100644
index 00000000..9b30040e
--- /dev/null
+++ b/scm/config_setup/docs/Labels.md
@@ -0,0 +1,31 @@
+# Labels
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | The description of the label | [optional]
+**id** | **str** | The UUID of the label | [readonly]
+**name** | **str** | The name of the label |
+
+## Example
+
+```python
+from scm.config_setup.models.labels import Labels
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Labels from a JSON string
+labels_instance = Labels.from_json(json)
+# print the JSON string representation of the object
+print(Labels.to_json())
+
+# convert the object into a dict
+labels_dict = labels_instance.to_dict()
+# create an instance of Labels from a dict
+labels_from_dict = Labels.from_dict(labels_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/LabelsApi.md b/scm/config_setup/docs/LabelsApi.md
new file mode 100644
index 00000000..4f7ec2d8
--- /dev/null
+++ b/scm/config_setup/docs/LabelsApi.md
@@ -0,0 +1,433 @@
+# scm.config_setup.LabelsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_label**](LabelsApi.md#create_label) | **POST** /labels | Create a label
+[**delete_label_by_id**](LabelsApi.md#delete_label_by_id) | **DELETE** /labels/{id} | Delete a label
+[**get_label_by_id**](LabelsApi.md#get_label_by_id) | **GET** /labels/{id} | Get a label
+[**list_labels**](LabelsApi.md#list_labels) | **GET** /labels | List labels
+[**update_label_by_id**](LabelsApi.md#update_label_by_id) | **PUT** /labels/{id} | Update a label
+
+
+# **create_label**
+> Labels create_label(labels=labels)
+
+Create a label
+
+Create a new label.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.labels import Labels
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.LabelsApi(api_client)
+ labels = scm.config_setup.Labels() # Labels | The `label` resource definition. (optional)
+
+ try:
+ # Create a label
+ api_response = api_instance.create_label(labels=labels)
+ print("The response of LabelsApi->create_label:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LabelsApi->create_label: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **labels** | [**Labels**](Labels.md)| The `label` resource definition. | [optional]
+
+### Return type
+
+[**Labels**](Labels.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_label_by_id**
+> delete_label_by_id(id)
+
+Delete a label
+
+Delete an existing label.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.LabelsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Delete a label
+ api_instance.delete_label_by_id(id)
+ except Exception as e:
+ print("Exception when calling LabelsApi->delete_label_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_label_by_id**
+> Labels get_label_by_id(id)
+
+Get a label
+
+Retrieve an existing label.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.labels import Labels
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.LabelsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Get a label
+ api_response = api_instance.get_label_by_id(id)
+ print("The response of LabelsApi->get_label_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LabelsApi->get_label_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+[**Labels**](Labels.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_labels**
+> LabelsListResponse list_labels(limit=limit, offset=offset, name=name)
+
+List labels
+
+Retrieve a list of labels.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.labels_list_response import LabelsListResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.LabelsApi(api_client)
+ limit = 56 # int | The maximum number of resources to return (optional)
+ offset = 56 # int | The offset into the list of resources returned (optional)
+ name = 'name_example' # str | The name of the resource (optional)
+
+ try:
+ # List labels
+ api_response = api_instance.list_labels(limit=limit, offset=offset, name=name)
+ print("The response of LabelsApi->list_labels:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LabelsApi->list_labels: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of resources to return | [optional]
+ **offset** | **int**| The offset into the list of resources returned | [optional]
+ **name** | **str**| The name of the resource | [optional]
+
+### Return type
+
+[**LabelsListResponse**](LabelsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_label_by_id**
+> Labels update_label_by_id(id, labels=labels)
+
+Update a label
+
+Update an existing label.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.labels import Labels
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.LabelsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+ labels = scm.config_setup.Labels() # Labels | The `label` resource definition. (optional)
+
+ try:
+ # Update a label
+ api_response = api_instance.update_label_by_id(id, labels=labels)
+ print("The response of LabelsApi->update_label_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LabelsApi->update_label_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+ **labels** | [**Labels**](Labels.md)| The `label` resource definition. | [optional]
+
+### Return type
+
+[**Labels**](Labels.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/LabelsListResponse.md b/scm/config_setup/docs/LabelsListResponse.md
new file mode 100644
index 00000000..c8637e2c
--- /dev/null
+++ b/scm/config_setup/docs/LabelsListResponse.md
@@ -0,0 +1,32 @@
+# LabelsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[Labels]**](Labels.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.config_setup.models.labels_list_response import LabelsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LabelsListResponse from a JSON string
+labels_list_response_instance = LabelsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(LabelsListResponse.to_json())
+
+# convert the object into a dict
+labels_list_response_dict = labels_list_response_instance.to_dict()
+# create an instance of LabelsListResponse from a dict
+labels_list_response_from_dict = LabelsListResponse.from_dict(labels_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/PropertyItem.md b/scm/config_setup/docs/PropertyItem.md
new file mode 100644
index 00000000..37b718ea
--- /dev/null
+++ b/scm/config_setup/docs/PropertyItem.md
@@ -0,0 +1,31 @@
+# PropertyItem
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **int** | | [optional]
+**name** | **str** | | [optional]
+**value** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.property_item import PropertyItem
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of PropertyItem from a JSON string
+property_item_instance = PropertyItem.from_json(json)
+# print the JSON string representation of the object
+print(PropertyItem.to_json())
+
+# convert the object into a dict
+property_item_dict = property_item_instance.to_dict()
+# create an instance of PropertyItem from a dict
+property_item_from_dict = PropertyItem.from_dict(property_item_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SaveSnippetSnapshotConfigResponse.md b/scm/config_setup/docs/SaveSnippetSnapshotConfigResponse.md
new file mode 100644
index 00000000..5a8ca920
--- /dev/null
+++ b/scm/config_setup/docs/SaveSnippetSnapshotConfigResponse.md
@@ -0,0 +1,30 @@
+# SaveSnippetSnapshotConfigResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**result** | [**SaveSnippetSnapshotConfigResponseResult**](SaveSnippetSnapshotConfigResponseResult.md) | | [optional]
+**status** | **str** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.save_snippet_snapshot_config_response import SaveSnippetSnapshotConfigResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SaveSnippetSnapshotConfigResponse from a JSON string
+save_snippet_snapshot_config_response_instance = SaveSnippetSnapshotConfigResponse.from_json(json)
+# print the JSON string representation of the object
+print(SaveSnippetSnapshotConfigResponse.to_json())
+
+# convert the object into a dict
+save_snippet_snapshot_config_response_dict = save_snippet_snapshot_config_response_instance.to_dict()
+# create an instance of SaveSnippetSnapshotConfigResponse from a dict
+save_snippet_snapshot_config_response_from_dict = SaveSnippetSnapshotConfigResponse.from_dict(save_snippet_snapshot_config_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SaveSnippetSnapshotConfigResponseResult.md b/scm/config_setup/docs/SaveSnippetSnapshotConfigResponseResult.md
new file mode 100644
index 00000000..3b974fa0
--- /dev/null
+++ b/scm/config_setup/docs/SaveSnippetSnapshotConfigResponseResult.md
@@ -0,0 +1,29 @@
+# SaveSnippetSnapshotConfigResponseResult
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**version** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.save_snippet_snapshot_config_response_result import SaveSnippetSnapshotConfigResponseResult
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SaveSnippetSnapshotConfigResponseResult from a JSON string
+save_snippet_snapshot_config_response_result_instance = SaveSnippetSnapshotConfigResponseResult.from_json(json)
+# print the JSON string representation of the object
+print(SaveSnippetSnapshotConfigResponseResult.to_json())
+
+# convert the object into a dict
+save_snippet_snapshot_config_response_result_dict = save_snippet_snapshot_config_response_result_instance.to_dict()
+# create an instance of SaveSnippetSnapshotConfigResponseResult from a dict
+save_snippet_snapshot_config_response_result_from_dict = SaveSnippetSnapshotConfigResponseResult.from_dict(save_snippet_snapshot_config_response_result_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SaveSnippetSnapshotPayload.md b/scm/config_setup/docs/SaveSnippetSnapshotPayload.md
new file mode 100644
index 00000000..0bc7331b
--- /dev/null
+++ b/scm/config_setup/docs/SaveSnippetSnapshotPayload.md
@@ -0,0 +1,30 @@
+# SaveSnippetSnapshotPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | |
+**id** | **str** | |
+
+## Example
+
+```python
+from scm.config_setup.models.save_snippet_snapshot_payload import SaveSnippetSnapshotPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SaveSnippetSnapshotPayload from a JSON string
+save_snippet_snapshot_payload_instance = SaveSnippetSnapshotPayload.from_json(json)
+# print the JSON string representation of the object
+print(SaveSnippetSnapshotPayload.to_json())
+
+# convert the object into a dict
+save_snippet_snapshot_payload_dict = save_snippet_snapshot_payload_instance.to_dict()
+# create an instance of SaveSnippetSnapshotPayload from a dict
+save_snippet_snapshot_payload_from_dict = SaveSnippetSnapshotPayload.from_dict(save_snippet_snapshot_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SharedSnippetsApi.md b/scm/config_setup/docs/SharedSnippetsApi.md
new file mode 100644
index 00000000..b374937e
--- /dev/null
+++ b/scm/config_setup/docs/SharedSnippetsApi.md
@@ -0,0 +1,257 @@
+# scm.config_setup.SharedSnippetsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**convert_shared_snippets**](SharedSnippetsApi.md#convert_shared_snippets) | **PUT** /shared-snippets | Update Shared Snippets
+[**list_shared_snippets**](SharedSnippetsApi.md#list_shared_snippets) | **GET** /shared-snippets | Get Shared Snippets
+[**load_shared_snippets**](SharedSnippetsApi.md#load_shared_snippets) | **POST** /shared-snippets:load | Load Shared Snippets
+
+
+# **convert_shared_snippets**
+> SnippetShareInfo convert_shared_snippets(snippet_share_upload_payload=snippet_share_upload_payload)
+
+Update Shared Snippets
+
+Update Shared Snippets.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from scm.config_setup.models.snippet_share_upload_payload import SnippetShareUploadPayload
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SharedSnippetsApi(api_client)
+ snippet_share_upload_payload = scm.config_setup.SnippetShareUploadPayload() # SnippetShareUploadPayload | The `Shared Snippets To Update` resource definition (optional)
+
+ try:
+ # Update Shared Snippets
+ api_response = api_instance.convert_shared_snippets(snippet_share_upload_payload=snippet_share_upload_payload)
+ print("The response of SharedSnippetsApi->convert_shared_snippets:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SharedSnippetsApi->convert_shared_snippets: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippet_share_upload_payload** | [**SnippetShareUploadPayload**](SnippetShareUploadPayload.md)| The `Shared Snippets To Update` resource definition | [optional]
+
+### Return type
+
+[**SnippetShareInfo**](SnippetShareInfo.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_shared_snippets**
+> List[SnippetShareInfo] list_shared_snippets()
+
+Get Shared Snippets
+
+Retrieve a list of shared snippets.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SharedSnippetsApi(api_client)
+
+ try:
+ # Get Shared Snippets
+ api_response = api_instance.list_shared_snippets()
+ print("The response of SharedSnippetsApi->list_shared_snippets:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SharedSnippetsApi->list_shared_snippets: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**List[SnippetShareInfo]**](SnippetShareInfo.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **load_shared_snippets**
+> SnippetShareLoadPayload load_shared_snippets(snippet_share_load_payload=snippet_share_load_payload)
+
+Load Shared Snippets
+
+Convert Snippet Snippets.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_share_load_payload import SnippetShareLoadPayload
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SharedSnippetsApi(api_client)
+ snippet_share_load_payload = scm.config_setup.SnippetShareLoadPayload() # SnippetShareLoadPayload | The `Snippet Snapshots To Convert` resource definition (optional)
+
+ try:
+ # Load Shared Snippets
+ api_response = api_instance.load_shared_snippets(snippet_share_load_payload=snippet_share_load_payload)
+ print("The response of SharedSnippetsApi->load_shared_snippets:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SharedSnippetsApi->load_shared_snippets: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippet_share_load_payload** | [**SnippetShareLoadPayload**](SnippetShareLoadPayload.md)| The `Snippet Snapshots To Convert` resource definition | [optional]
+
+### Return type
+
+[**SnippetShareLoadPayload**](SnippetShareLoadPayload.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/SnippetAuditHistory.md b/scm/config_setup/docs/SnippetAuditHistory.md
new file mode 100644
index 00000000..2a84a05d
--- /dev/null
+++ b/scm/config_setup/docs/SnippetAuditHistory.md
@@ -0,0 +1,42 @@
+# SnippetAuditHistory
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional] [readonly]
+**created** | **datetime** | | [optional] [readonly]
+**deleted** | **int** | | [optional] [readonly]
+**details** | **str** | | [optional] [readonly]
+**display** | **int** | | [optional] [readonly]
+**donor_created** | **int** | | [optional] [readonly]
+**donor_tenant_name** | **str** | | [optional] [readonly]
+**donor_tsg** | **str** | | [optional] [readonly]
+**id** | **int** | | [optional] [readonly]
+**recipient_tenant_name** | **str** | | [optional] [readonly]
+**recipient_tsg** | **str** | | [optional] [readonly]
+**snippet_uuid** | **str** | | [optional] [readonly]
+**user** | **str** | | [optional] [readonly]
+**version** | **str** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_audit_history import SnippetAuditHistory
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetAuditHistory from a JSON string
+snippet_audit_history_instance = SnippetAuditHistory.from_json(json)
+# print the JSON string representation of the object
+print(SnippetAuditHistory.to_json())
+
+# convert the object into a dict
+snippet_audit_history_dict = snippet_audit_history_instance.to_dict()
+# create an instance of SnippetAuditHistory from a dict
+snippet_audit_history_from_dict = SnippetAuditHistory.from_dict(snippet_audit_history_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetAuditLogsApi.md b/scm/config_setup/docs/SnippetAuditLogsApi.md
new file mode 100644
index 00000000..2600f393
--- /dev/null
+++ b/scm/config_setup/docs/SnippetAuditLogsApi.md
@@ -0,0 +1,179 @@
+# scm.config_setup.SnippetAuditLogsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_snippet_audit_logs**](SnippetAuditLogsApi.md#create_snippet_audit_logs) | **POST** /snippet-audit-logs | Create snippet audit logs configuration
+[**get_snippet_audit_logs_by_id**](SnippetAuditLogsApi.md#get_snippet_audit_logs_by_id) | **GET** /snippet-audit-logs/{id} | Get a snippet audit logs
+
+
+# **create_snippet_audit_logs**
+> SnippetAuditHistory create_snippet_audit_logs(snippet_audit_payload=snippet_audit_payload)
+
+Create snippet audit logs configuration
+
+Create snippet audit logs configuration.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_audit_history import SnippetAuditHistory
+from scm.config_setup.models.snippet_audit_payload import SnippetAuditPayload
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetAuditLogsApi(api_client)
+ snippet_audit_payload = scm.config_setup.SnippetAuditPayload() # SnippetAuditPayload | The `Snippet Snapshots To Convert` resource definition (optional)
+
+ try:
+ # Create snippet audit logs configuration
+ api_response = api_instance.create_snippet_audit_logs(snippet_audit_payload=snippet_audit_payload)
+ print("The response of SnippetAuditLogsApi->create_snippet_audit_logs:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetAuditLogsApi->create_snippet_audit_logs: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippet_audit_payload** | [**SnippetAuditPayload**](SnippetAuditPayload.md)| The `Snippet Snapshots To Convert` resource definition | [optional]
+
+### Return type
+
+[**SnippetAuditHistory**](SnippetAuditHistory.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_snippet_audit_logs_by_id**
+> SnippetAuditHistory get_snippet_audit_logs_by_id(id, type)
+
+Get a snippet audit logs
+
+Retrieve an existing snippet audit logs by UUID.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_audit_history import SnippetAuditHistory
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetAuditLogsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+ type = 'type_example' # str | Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'.
+
+ try:
+ # Get a snippet audit logs
+ api_response = api_instance.get_snippet_audit_logs_by_id(id, type)
+ print("The response of SnippetAuditLogsApi->get_snippet_audit_logs_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetAuditLogsApi->get_snippet_audit_logs_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+ **type** | **str**| Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. |
+
+### Return type
+
+[**SnippetAuditHistory**](SnippetAuditHistory.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/SnippetAuditPayload.md b/scm/config_setup/docs/SnippetAuditPayload.md
new file mode 100644
index 00000000..a4f4c7aa
--- /dev/null
+++ b/scm/config_setup/docs/SnippetAuditPayload.md
@@ -0,0 +1,37 @@
+# SnippetAuditPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**details** | **str** | | [optional]
+**donor_created** | **int** | | [optional]
+**donor_tenant_name** | **str** | | [optional]
+**donor_tsg** | **str** | | [optional]
+**recipient_tenant_name** | **str** | | [optional]
+**recipient_tsg** | **str** | | [optional]
+**snippet_uuid** | **str** | | [optional]
+**version** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_audit_payload import SnippetAuditPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetAuditPayload from a JSON string
+snippet_audit_payload_instance = SnippetAuditPayload.from_json(json)
+# print the JSON string representation of the object
+print(SnippetAuditPayload.to_json())
+
+# convert the object into a dict
+snippet_audit_payload_dict = snippet_audit_payload_instance.to_dict()
+# create an instance of SnippetAuditPayload from a dict
+snippet_audit_payload_from_dict = SnippetAuditPayload.from_dict(snippet_audit_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetCategories.md b/scm/config_setup/docs/SnippetCategories.md
new file mode 100644
index 00000000..40813418
--- /dev/null
+++ b/scm/config_setup/docs/SnippetCategories.md
@@ -0,0 +1,56 @@
+# SnippetCategories
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**created_in** | **datetime** | | [optional] [readonly]
+**description** | **str** | | [optional] [readonly]
+**display_name** | **str** | | [optional] [readonly]
+**donor_created** | **int** | | [optional] [readonly]
+**donor_snippet_file_id** | **int** | | [optional] [readonly]
+**donor_snippet_version** | **int** | | [optional] [readonly]
+**donor_tenant_id** | **str** | | [optional] [readonly]
+**donor_tenant_name** | **str** | | [optional] [readonly]
+**donor_tsg** | **str** | | [optional] [readonly]
+**enable_prefix** | **bool** | | [optional] [readonly]
+**error** | **str** | | [optional] [readonly]
+**folders** | [**List[UsedFolders]**](UsedFolders.md) | | [optional]
+**id** | **str** | | [readonly]
+**labels** | **List[str]** | | [optional]
+**last_update** | **datetime** | | [optional] [readonly]
+**msg_uuid** | **str** | | [optional] [readonly]
+**name** | **str** | | [readonly]
+**prefix** | **str** | | [optional] [readonly]
+**recipient_paused_update** | **bool** | | [optional] [readonly]
+**recipient_tenant_id** | **str** | | [optional] [readonly]
+**recipient_tenant_name** | **str** | | [optional] [readonly]
+**recipient_tsg** | **str** | | [optional] [readonly]
+**recipient_validate_before_update** | **bool** | | [optional] [readonly]
+**shared_in** | **str** | | [optional] [readonly]
+**snippet_uuid** | **str** | | [optional] [readonly]
+**status** | **str** | | [optional] [readonly]
+**type** | **str** | | [optional] [readonly]
+**version** | **int** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_categories import SnippetCategories
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetCategories from a JSON string
+snippet_categories_instance = SnippetCategories.from_json(json)
+# print the JSON string representation of the object
+print(SnippetCategories.to_json())
+
+# convert the object into a dict
+snippet_categories_dict = snippet_categories_instance.to_dict()
+# create an instance of SnippetCategories from a dict
+snippet_categories_from_dict = SnippetCategories.from_dict(snippet_categories_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetCategoriesApi.md b/scm/config_setup/docs/SnippetCategoriesApi.md
new file mode 100644
index 00000000..8e0be77d
--- /dev/null
+++ b/scm/config_setup/docs/SnippetCategoriesApi.md
@@ -0,0 +1,262 @@
+# scm.config_setup.SnippetCategoriesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**delete_snippet_category_by_id**](SnippetCategoriesApi.md#delete_snippet_category_by_id) | **DELETE** /snippet-categories/{id} | Delete a snippet category
+[**get_snippet_category_by_id**](SnippetCategoriesApi.md#get_snippet_category_by_id) | **GET** /snippet-categories/{id} | Get a snippet category
+[**list_snippet_categories**](SnippetCategoriesApi.md#list_snippet_categories) | **GET** /snippet-categories | List snippets categories
+
+
+# **delete_snippet_category_by_id**
+> delete_snippet_category_by_id(id)
+
+Delete a snippet category
+
+Delete an existing snippet category.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetCategoriesApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Delete a snippet category
+ api_instance.delete_snippet_category_by_id(id)
+ except Exception as e:
+ print("Exception when calling SnippetCategoriesApi->delete_snippet_category_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_snippet_category_by_id**
+> SnippetCategories get_snippet_category_by_id(id)
+
+Get a snippet category
+
+Retrieve an existing snippet category.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_categories import SnippetCategories
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetCategoriesApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Get a snippet category
+ api_response = api_instance.get_snippet_category_by_id(id)
+ print("The response of SnippetCategoriesApi->get_snippet_category_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetCategoriesApi->get_snippet_category_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+[**SnippetCategories**](SnippetCategories.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_snippet_categories**
+> SnippetCategoriesListResponse list_snippet_categories(limit=limit, offset=offset, name=name)
+
+List snippets categories
+
+Retrieve a list of snippet categories.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_categories_list_response import SnippetCategoriesListResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetCategoriesApi(api_client)
+ limit = 56 # int | The maximum number of resources to return (optional)
+ offset = 56 # int | The offset into the list of resources returned (optional)
+ name = 'name_example' # str | The name of the resource (optional)
+
+ try:
+ # List snippets categories
+ api_response = api_instance.list_snippet_categories(limit=limit, offset=offset, name=name)
+ print("The response of SnippetCategoriesApi->list_snippet_categories:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetCategoriesApi->list_snippet_categories: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of resources to return | [optional]
+ **offset** | **int**| The offset into the list of resources returned | [optional]
+ **name** | **str**| The name of the resource | [optional]
+
+### Return type
+
+[**SnippetCategoriesListResponse**](SnippetCategoriesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/SnippetCategoriesListResponse.md b/scm/config_setup/docs/SnippetCategoriesListResponse.md
new file mode 100644
index 00000000..8db7291d
--- /dev/null
+++ b/scm/config_setup/docs/SnippetCategoriesListResponse.md
@@ -0,0 +1,32 @@
+# SnippetCategoriesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[SnippetCategories]**](SnippetCategories.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_categories_list_response import SnippetCategoriesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetCategoriesListResponse from a JSON string
+snippet_categories_list_response_instance = SnippetCategoriesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(SnippetCategoriesListResponse.to_json())
+
+# convert the object into a dict
+snippet_categories_list_response_dict = snippet_categories_list_response_instance.to_dict()
+# create an instance of SnippetCategoriesListResponse from a dict
+snippet_categories_list_response_from_dict = SnippetCategoriesListResponse.from_dict(snippet_categories_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetShareInfo.md b/scm/config_setup/docs/SnippetShareInfo.md
new file mode 100644
index 00000000..b47136bd
--- /dev/null
+++ b/scm/config_setup/docs/SnippetShareInfo.md
@@ -0,0 +1,50 @@
+# SnippetShareInfo
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**created** | **datetime** | | [optional] [readonly]
+**donor_created** | **int** | | [optional] [readonly]
+**donor_snippet_file_id** | **int** | | [optional] [readonly]
+**donor_snippet_version** | **int** | | [optional] [readonly]
+**donor_tenant_id** | **str** | | [optional] [readonly]
+**donor_tenant_name** | **str** | | [optional] [readonly]
+**donor_tsg** | **str** | | [optional] [readonly]
+**error** | **str** | | [optional] [readonly]
+**id** | **int** | | [optional] [readonly]
+**last_updated** | **datetime** | | [optional] [readonly]
+**msg_uuid** | **str** | | [optional] [readonly]
+**properties** | [**List[SnippetShareProperty]**](SnippetShareProperty.md) | | [optional]
+**recipient_paused_update** | **bool** | | [optional] [readonly]
+**recipient_snippet_file_id** | **int** | | [optional] [readonly]
+**recipient_snippet_version** | **int** | | [optional] [readonly]
+**recipient_tenant_id** | **str** | | [optional] [readonly]
+**recipient_tenant_name** | **str** | | [optional] [readonly]
+**recipient_tsg** | **str** | | [optional] [readonly]
+**recipient_validate_before_update** | **bool** | | [optional] [readonly]
+**snippet_name** | **str** | | [optional] [readonly]
+**snippet_uuid** | **str** | | [optional] [readonly]
+**status** | **str** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetShareInfo from a JSON string
+snippet_share_info_instance = SnippetShareInfo.from_json(json)
+# print the JSON string representation of the object
+print(SnippetShareInfo.to_json())
+
+# convert the object into a dict
+snippet_share_info_dict = snippet_share_info_instance.to_dict()
+# create an instance of SnippetShareInfo from a dict
+snippet_share_info_from_dict = SnippetShareInfo.from_dict(snippet_share_info_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetShareLoadPayload.md b/scm/config_setup/docs/SnippetShareLoadPayload.md
new file mode 100644
index 00000000..16144d36
--- /dev/null
+++ b/scm/config_setup/docs/SnippetShareLoadPayload.md
@@ -0,0 +1,30 @@
+# SnippetShareLoadPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | |
+**validation** | **bool** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_share_load_payload import SnippetShareLoadPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetShareLoadPayload from a JSON string
+snippet_share_load_payload_instance = SnippetShareLoadPayload.from_json(json)
+# print the JSON string representation of the object
+print(SnippetShareLoadPayload.to_json())
+
+# convert the object into a dict
+snippet_share_load_payload_dict = snippet_share_load_payload_instance.to_dict()
+# create an instance of SnippetShareLoadPayload from a dict
+snippet_share_load_payload_from_dict = SnippetShareLoadPayload.from_dict(snippet_share_load_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetShareProperty.md b/scm/config_setup/docs/SnippetShareProperty.md
new file mode 100644
index 00000000..a94f16e3
--- /dev/null
+++ b/scm/config_setup/docs/SnippetShareProperty.md
@@ -0,0 +1,44 @@
+# SnippetShareProperty
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**created** | **datetime** | | [optional] [readonly]
+**created_by** | **str** | | [optional] [readonly]
+**donor_tenant** | **str** | | [optional] [readonly]
+**donor_tsg** | **str** | | [optional] [readonly]
+**error** | **str** | | [optional] [readonly]
+**id** | **int** | | [optional] [readonly]
+**msg_uuid** | **str** | | [optional] [readonly]
+**property_name** | **str** | | [optional] [readonly]
+**property_value** | **str** | | [optional] [readonly]
+**recipient_tenant** | **str** | | [optional] [readonly]
+**recipient_tsg** | **str** | | [optional] [readonly]
+**snippet_name** | **str** | | [optional] [readonly]
+**snippet_uuid** | **str** | | [optional] [readonly]
+**status** | **str** | | [optional] [readonly]
+**updated** | **datetime** | | [optional] [readonly]
+**updated_by** | **str** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_share_property import SnippetShareProperty
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetShareProperty from a JSON string
+snippet_share_property_instance = SnippetShareProperty.from_json(json)
+# print the JSON string representation of the object
+print(SnippetShareProperty.to_json())
+
+# convert the object into a dict
+snippet_share_property_dict = snippet_share_property_instance.to_dict()
+# create an instance of SnippetShareProperty from a dict
+snippet_share_property_from_dict = SnippetShareProperty.from_dict(snippet_share_property_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetShareUploadPayload.md b/scm/config_setup/docs/SnippetShareUploadPayload.md
new file mode 100644
index 00000000..ad89a680
--- /dev/null
+++ b/scm/config_setup/docs/SnippetShareUploadPayload.md
@@ -0,0 +1,31 @@
+# SnippetShareUploadPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | |
+**pause_update** | **bool** | | [optional]
+**validate_before_update** | **bool** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_share_upload_payload import SnippetShareUploadPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetShareUploadPayload from a JSON string
+snippet_share_upload_payload_instance = SnippetShareUploadPayload.from_json(json)
+# print the JSON string representation of the object
+print(SnippetShareUploadPayload.to_json())
+
+# convert the object into a dict
+snippet_share_upload_payload_dict = snippet_share_upload_payload_instance.to_dict()
+# create an instance of SnippetShareUploadPayload from a dict
+snippet_share_upload_payload_from_dict = SnippetShareUploadPayload.from_dict(snippet_share_upload_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotCompareEntry.md b/scm/config_setup/docs/SnippetSnapshotCompareEntry.md
new file mode 100644
index 00000000..b33ab8ae
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotCompareEntry.md
@@ -0,0 +1,36 @@
+# SnippetSnapshotCompareEntry
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**admin** | **str** | | [optional] [readonly]
+**id** | **str** | | [optional] [readonly]
+**loc** | **str** | | [optional]
+**loctype** | **str** | | [optional]
+**objectname** | **str** | | [optional]
+**objecttype** | **str** | | [optional]
+**operations** | **str** | | [optional]
+**timestamp** | **datetime** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_compare_entry import SnippetSnapshotCompareEntry
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotCompareEntry from a JSON string
+snippet_snapshot_compare_entry_instance = SnippetSnapshotCompareEntry.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotCompareEntry.to_json())
+
+# convert the object into a dict
+snippet_snapshot_compare_entry_dict = snippet_snapshot_compare_entry_instance.to_dict()
+# create an instance of SnippetSnapshotCompareEntry from a dict
+snippet_snapshot_compare_entry_from_dict = SnippetSnapshotCompareEntry.from_dict(snippet_snapshot_compare_entry_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotDiffResponse.md b/scm/config_setup/docs/SnippetSnapshotDiffResponse.md
new file mode 100644
index 00000000..b2bcf7a6
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotDiffResponse.md
@@ -0,0 +1,30 @@
+# SnippetSnapshotDiffResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**after** | [**SnippetSnapshotDiffResponseAfter**](SnippetSnapshotDiffResponseAfter.md) | | [optional]
+**before** | [**SnippetSnapshotDiffResponseBefore**](SnippetSnapshotDiffResponseBefore.md) | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_diff_response import SnippetSnapshotDiffResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotDiffResponse from a JSON string
+snippet_snapshot_diff_response_instance = SnippetSnapshotDiffResponse.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotDiffResponse.to_json())
+
+# convert the object into a dict
+snippet_snapshot_diff_response_dict = snippet_snapshot_diff_response_instance.to_dict()
+# create an instance of SnippetSnapshotDiffResponse from a dict
+snippet_snapshot_diff_response_from_dict = SnippetSnapshotDiffResponse.from_dict(snippet_snapshot_diff_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotDiffResponseAfter.md b/scm/config_setup/docs/SnippetSnapshotDiffResponseAfter.md
new file mode 100644
index 00000000..5f0ec312
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotDiffResponseAfter.md
@@ -0,0 +1,30 @@
+# SnippetSnapshotDiffResponseAfter
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ts** | **datetime** | | [optional] [readonly]
+**entry** | **List[object]** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_diff_response_after import SnippetSnapshotDiffResponseAfter
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotDiffResponseAfter from a JSON string
+snippet_snapshot_diff_response_after_instance = SnippetSnapshotDiffResponseAfter.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotDiffResponseAfter.to_json())
+
+# convert the object into a dict
+snippet_snapshot_diff_response_after_dict = snippet_snapshot_diff_response_after_instance.to_dict()
+# create an instance of SnippetSnapshotDiffResponseAfter from a dict
+snippet_snapshot_diff_response_after_from_dict = SnippetSnapshotDiffResponseAfter.from_dict(snippet_snapshot_diff_response_after_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotDiffResponseBefore.md b/scm/config_setup/docs/SnippetSnapshotDiffResponseBefore.md
new file mode 100644
index 00000000..9da0e697
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotDiffResponseBefore.md
@@ -0,0 +1,30 @@
+# SnippetSnapshotDiffResponseBefore
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ts** | **datetime** | | [optional]
+**entry** | **List[object]** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_diff_response_before import SnippetSnapshotDiffResponseBefore
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotDiffResponseBefore from a JSON string
+snippet_snapshot_diff_response_before_instance = SnippetSnapshotDiffResponseBefore.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotDiffResponseBefore.to_json())
+
+# convert the object into a dict
+snippet_snapshot_diff_response_before_dict = snippet_snapshot_diff_response_before_instance.to_dict()
+# create an instance of SnippetSnapshotDiffResponseBefore from a dict
+snippet_snapshot_diff_response_before_from_dict = SnippetSnapshotDiffResponseBefore.from_dict(snippet_snapshot_diff_response_before_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotLoadSnippetPayload.md b/scm/config_setup/docs/SnippetSnapshotLoadSnippetPayload.md
new file mode 100644
index 00000000..773d522b
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotLoadSnippetPayload.md
@@ -0,0 +1,30 @@
+# SnippetSnapshotLoadSnippetPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | |
+**version** | **str** | |
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_load_snippet_payload import SnippetSnapshotLoadSnippetPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotLoadSnippetPayload from a JSON string
+snippet_snapshot_load_snippet_payload_instance = SnippetSnapshotLoadSnippetPayload.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotLoadSnippetPayload.to_json())
+
+# convert the object into a dict
+snippet_snapshot_load_snippet_payload_dict = snippet_snapshot_load_snippet_payload_instance.to_dict()
+# create an instance of SnippetSnapshotLoadSnippetPayload from a dict
+snippet_snapshot_load_snippet_payload_from_dict = SnippetSnapshotLoadSnippetPayload.from_dict(snippet_snapshot_load_snippet_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotLoadSnippetResponse.md b/scm/config_setup/docs/SnippetSnapshotLoadSnippetResponse.md
new file mode 100644
index 00000000..91bab376
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotLoadSnippetResponse.md
@@ -0,0 +1,29 @@
+# SnippetSnapshotLoadSnippetResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**status** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_load_snippet_response import SnippetSnapshotLoadSnippetResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotLoadSnippetResponse from a JSON string
+snippet_snapshot_load_snippet_response_instance = SnippetSnapshotLoadSnippetResponse.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotLoadSnippetResponse.to_json())
+
+# convert the object into a dict
+snippet_snapshot_load_snippet_response_dict = snippet_snapshot_load_snippet_response_instance.to_dict()
+# create an instance of SnippetSnapshotLoadSnippetResponse from a dict
+snippet_snapshot_load_snippet_response_from_dict = SnippetSnapshotLoadSnippetResponse.from_dict(snippet_snapshot_load_snippet_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotPublishRequest.md b/scm/config_setup/docs/SnippetSnapshotPublishRequest.md
new file mode 100644
index 00000000..3adb40ab
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotPublishRequest.md
@@ -0,0 +1,33 @@
+# SnippetSnapshotPublishRequest
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | | [optional]
+**name** | **str** | | [optional]
+**tsgs** | **List[str]** | | [optional]
+**validation** | **bool** | | [optional]
+**version** | **int** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_publish_request import SnippetSnapshotPublishRequest
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotPublishRequest from a JSON string
+snippet_snapshot_publish_request_instance = SnippetSnapshotPublishRequest.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotPublishRequest.to_json())
+
+# convert the object into a dict
+snippet_snapshot_publish_request_dict = snippet_snapshot_publish_request_instance.to_dict()
+# create an instance of SnippetSnapshotPublishRequest from a dict
+snippet_snapshot_publish_request_from_dict = SnippetSnapshotPublishRequest.from_dict(snippet_snapshot_publish_request_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotPublishResponse.md b/scm/config_setup/docs/SnippetSnapshotPublishResponse.md
new file mode 100644
index 00000000..00ab86c7
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotPublishResponse.md
@@ -0,0 +1,33 @@
+# SnippetSnapshotPublishResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**file_id** | **int** | | [optional] [readonly]
+**id** | **str** | | [optional] [readonly]
+**job_id** | **int** | | [optional] [readonly]
+**tsgs** | **List[str]** | | [optional] [readonly]
+**version** | **int** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_publish_response import SnippetSnapshotPublishResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotPublishResponse from a JSON string
+snippet_snapshot_publish_response_instance = SnippetSnapshotPublishResponse.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotPublishResponse.to_json())
+
+# convert the object into a dict
+snippet_snapshot_publish_response_dict = snippet_snapshot_publish_response_instance.to_dict()
+# create an instance of SnippetSnapshotPublishResponse from a dict
+snippet_snapshot_publish_response_from_dict = SnippetSnapshotPublishResponse.from_dict(snippet_snapshot_publish_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotSubscriberComparePayload.md b/scm/config_setup/docs/SnippetSnapshotSubscriberComparePayload.md
new file mode 100644
index 00000000..a300c7bb
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotSubscriberComparePayload.md
@@ -0,0 +1,30 @@
+# SnippetSnapshotSubscriberComparePayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | |
+**tenant_id** | **str** | Publisher Tenant ID |
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_payload import SnippetSnapshotSubscriberComparePayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotSubscriberComparePayload from a JSON string
+snippet_snapshot_subscriber_compare_payload_instance = SnippetSnapshotSubscriberComparePayload.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotSubscriberComparePayload.to_json())
+
+# convert the object into a dict
+snippet_snapshot_subscriber_compare_payload_dict = snippet_snapshot_subscriber_compare_payload_instance.to_dict()
+# create an instance of SnippetSnapshotSubscriberComparePayload from a dict
+snippet_snapshot_subscriber_compare_payload_from_dict = SnippetSnapshotSubscriberComparePayload.from_dict(snippet_snapshot_subscriber_compare_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotSubscriberCompareResponse.md b/scm/config_setup/docs/SnippetSnapshotSubscriberCompareResponse.md
new file mode 100644
index 00000000..e0db5e4b
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotSubscriberCompareResponse.md
@@ -0,0 +1,30 @@
+# SnippetSnapshotSubscriberCompareResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**publisher** | [**SnippetSnapshotSubscriberCompareResponsePublisher**](SnippetSnapshotSubscriberCompareResponsePublisher.md) | | [optional]
+**subscriber** | [**SnippetSnapshotSubscriberCompareResponsePublisher**](SnippetSnapshotSubscriberCompareResponsePublisher.md) | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response import SnippetSnapshotSubscriberCompareResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotSubscriberCompareResponse from a JSON string
+snippet_snapshot_subscriber_compare_response_instance = SnippetSnapshotSubscriberCompareResponse.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotSubscriberCompareResponse.to_json())
+
+# convert the object into a dict
+snippet_snapshot_subscriber_compare_response_dict = snippet_snapshot_subscriber_compare_response_instance.to_dict()
+# create an instance of SnippetSnapshotSubscriberCompareResponse from a dict
+snippet_snapshot_subscriber_compare_response_from_dict = SnippetSnapshotSubscriberCompareResponse.from_dict(snippet_snapshot_subscriber_compare_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotSubscriberCompareResponsePublisher.md b/scm/config_setup/docs/SnippetSnapshotSubscriberCompareResponsePublisher.md
new file mode 100644
index 00000000..b0eaa02f
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotSubscriberCompareResponsePublisher.md
@@ -0,0 +1,29 @@
+# SnippetSnapshotSubscriberCompareResponsePublisher
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**entry** | **List[object]** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response_publisher import SnippetSnapshotSubscriberCompareResponsePublisher
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetSnapshotSubscriberCompareResponsePublisher from a JSON string
+snippet_snapshot_subscriber_compare_response_publisher_instance = SnippetSnapshotSubscriberCompareResponsePublisher.from_json(json)
+# print the JSON string representation of the object
+print(SnippetSnapshotSubscriberCompareResponsePublisher.to_json())
+
+# convert the object into a dict
+snippet_snapshot_subscriber_compare_response_publisher_dict = snippet_snapshot_subscriber_compare_response_publisher_instance.to_dict()
+# create an instance of SnippetSnapshotSubscriberCompareResponsePublisher from a dict
+snippet_snapshot_subscriber_compare_response_publisher_from_dict = SnippetSnapshotSubscriberCompareResponsePublisher.from_dict(snippet_snapshot_subscriber_compare_response_publisher_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetSnapshotsApi.md b/scm/config_setup/docs/SnippetSnapshotsApi.md
new file mode 100644
index 00000000..329f7d1a
--- /dev/null
+++ b/scm/config_setup/docs/SnippetSnapshotsApi.md
@@ -0,0 +1,602 @@
+# scm.config_setup.SnippetSnapshotsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**compare_snippet_snapshot**](SnippetSnapshotsApi.md#compare_snippet_snapshot) | **POST** /snippet-snapshots:compare | Compare Snippet Snapshots
+[**convert_snippet_snapshot**](SnippetSnapshotsApi.md#convert_snippet_snapshot) | **POST** /snippet-snapshots:convert | Convert Snippet Snapshots
+[**diff_snippet_snapshot**](SnippetSnapshotsApi.md#diff_snippet_snapshot) | **POST** /snippet-snapshots:diff | Diff Snippet Snapshots
+[**load_snippet_snapshot**](SnippetSnapshotsApi.md#load_snippet_snapshot) | **POST** /snippet-snapshots:load | Load Snippet Snapshots
+[**publish_snippet_snapshot**](SnippetSnapshotsApi.md#publish_snippet_snapshot) | **POST** /snippet-snapshots:publish | Publish Snippet Snapshots
+[**save_snippet_snapshot**](SnippetSnapshotsApi.md#save_snippet_snapshot) | **POST** /snippet-snapshots | Save Snippet Snapshots
+[**update_snippet_snapshot**](SnippetSnapshotsApi.md#update_snippet_snapshot) | **POST** /snippet-snapshots:updates | Update Snippet Snapshots
+
+
+# **compare_snippet_snapshot**
+> List[SnippetSnapshotCompareEntry] compare_snippet_snapshot(compare_snippet_snapshot_config_payload=compare_snippet_snapshot_config_payload)
+
+Compare Snippet Snapshots
+
+Compare Snippet Snapshots.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.compare_snippet_snapshot_config_payload import CompareSnippetSnapshotConfigPayload
+from scm.config_setup.models.snippet_snapshot_compare_entry import SnippetSnapshotCompareEntry
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetSnapshotsApi(api_client)
+ compare_snippet_snapshot_config_payload = scm.config_setup.CompareSnippetSnapshotConfigPayload() # CompareSnippetSnapshotConfigPayload | The `Snippet Snapshots To Compare` resource definition (optional)
+
+ try:
+ # Compare Snippet Snapshots
+ api_response = api_instance.compare_snippet_snapshot(compare_snippet_snapshot_config_payload=compare_snippet_snapshot_config_payload)
+ print("The response of SnippetSnapshotsApi->compare_snippet_snapshot:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetSnapshotsApi->compare_snippet_snapshot: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **compare_snippet_snapshot_config_payload** | [**CompareSnippetSnapshotConfigPayload**](CompareSnippetSnapshotConfigPayload.md)| The `Snippet Snapshots To Compare` resource definition | [optional]
+
+### Return type
+
+[**List[SnippetSnapshotCompareEntry]**](SnippetSnapshotCompareEntry.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **convert_snippet_snapshot**
+> object convert_snippet_snapshot(common_snippet_snapshot_payload=common_snippet_snapshot_payload)
+
+Convert Snippet Snapshots
+
+Convert Snippet Snapshots.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.common_snippet_snapshot_payload import CommonSnippetSnapshotPayload
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetSnapshotsApi(api_client)
+ common_snippet_snapshot_payload = scm.config_setup.CommonSnippetSnapshotPayload() # CommonSnippetSnapshotPayload | The `Snippet Snapshots To Convert` resource definition (optional)
+
+ try:
+ # Convert Snippet Snapshots
+ api_response = api_instance.convert_snippet_snapshot(common_snippet_snapshot_payload=common_snippet_snapshot_payload)
+ print("The response of SnippetSnapshotsApi->convert_snippet_snapshot:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetSnapshotsApi->convert_snippet_snapshot: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **common_snippet_snapshot_payload** | [**CommonSnippetSnapshotPayload**](CommonSnippetSnapshotPayload.md)| The `Snippet Snapshots To Convert` resource definition | [optional]
+
+### Return type
+
+**object**
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **diff_snippet_snapshot**
+> SnippetSnapshotDiffResponse diff_snippet_snapshot(compare_tlo_payload=compare_tlo_payload)
+
+Diff Snippet Snapshots
+
+Diff Snippet Snapshots.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.compare_tlo_payload import CompareTloPayload
+from scm.config_setup.models.snippet_snapshot_diff_response import SnippetSnapshotDiffResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetSnapshotsApi(api_client)
+ compare_tlo_payload = scm.config_setup.CompareTloPayload() # CompareTloPayload | The `Snippet Snapshots To Differentiate` resource definition (optional)
+
+ try:
+ # Diff Snippet Snapshots
+ api_response = api_instance.diff_snippet_snapshot(compare_tlo_payload=compare_tlo_payload)
+ print("The response of SnippetSnapshotsApi->diff_snippet_snapshot:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetSnapshotsApi->diff_snippet_snapshot: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **compare_tlo_payload** | [**CompareTloPayload**](CompareTloPayload.md)| The `Snippet Snapshots To Differentiate` resource definition | [optional]
+
+### Return type
+
+[**SnippetSnapshotDiffResponse**](SnippetSnapshotDiffResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **load_snippet_snapshot**
+> SnippetSnapshotLoadSnippetResponse load_snippet_snapshot(snippet_snapshot_load_snippet_payload=snippet_snapshot_load_snippet_payload)
+
+Load Snippet Snapshots
+
+Load Snippet Snapshots.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_snapshot_load_snippet_payload import SnippetSnapshotLoadSnippetPayload
+from scm.config_setup.models.snippet_snapshot_load_snippet_response import SnippetSnapshotLoadSnippetResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetSnapshotsApi(api_client)
+ snippet_snapshot_load_snippet_payload = scm.config_setup.SnippetSnapshotLoadSnippetPayload() # SnippetSnapshotLoadSnippetPayload | The `Snippet Snapshots To Load` resource definition (optional)
+
+ try:
+ # Load Snippet Snapshots
+ api_response = api_instance.load_snippet_snapshot(snippet_snapshot_load_snippet_payload=snippet_snapshot_load_snippet_payload)
+ print("The response of SnippetSnapshotsApi->load_snippet_snapshot:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetSnapshotsApi->load_snippet_snapshot: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippet_snapshot_load_snippet_payload** | [**SnippetSnapshotLoadSnippetPayload**](SnippetSnapshotLoadSnippetPayload.md)| The `Snippet Snapshots To Load` resource definition | [optional]
+
+### Return type
+
+[**SnippetSnapshotLoadSnippetResponse**](SnippetSnapshotLoadSnippetResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **publish_snippet_snapshot**
+> SnippetSnapshotPublishResponse publish_snippet_snapshot(snippet_snapshot_publish_request=snippet_snapshot_publish_request)
+
+Publish Snippet Snapshots
+
+Publish Snippet Snapshots.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_snapshot_publish_request import SnippetSnapshotPublishRequest
+from scm.config_setup.models.snippet_snapshot_publish_response import SnippetSnapshotPublishResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetSnapshotsApi(api_client)
+ snippet_snapshot_publish_request = scm.config_setup.SnippetSnapshotPublishRequest() # SnippetSnapshotPublishRequest | The `Snippet Snapshots To Publish` resource definition (optional)
+
+ try:
+ # Publish Snippet Snapshots
+ api_response = api_instance.publish_snippet_snapshot(snippet_snapshot_publish_request=snippet_snapshot_publish_request)
+ print("The response of SnippetSnapshotsApi->publish_snippet_snapshot:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetSnapshotsApi->publish_snippet_snapshot: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippet_snapshot_publish_request** | [**SnippetSnapshotPublishRequest**](SnippetSnapshotPublishRequest.md)| The `Snippet Snapshots To Publish` resource definition | [optional]
+
+### Return type
+
+[**SnippetSnapshotPublishResponse**](SnippetSnapshotPublishResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **save_snippet_snapshot**
+> SaveSnippetSnapshotConfigResponse save_snippet_snapshot(save_snippet_snapshot_payload=save_snippet_snapshot_payload)
+
+Save Snippet Snapshots
+
+Save Snippet Snapshots.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.save_snippet_snapshot_config_response import SaveSnippetSnapshotConfigResponse
+from scm.config_setup.models.save_snippet_snapshot_payload import SaveSnippetSnapshotPayload
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetSnapshotsApi(api_client)
+ save_snippet_snapshot_payload = scm.config_setup.SaveSnippetSnapshotPayload() # SaveSnippetSnapshotPayload | The `Save Snippet Snapshots` resource definition (optional)
+
+ try:
+ # Save Snippet Snapshots
+ api_response = api_instance.save_snippet_snapshot(save_snippet_snapshot_payload=save_snippet_snapshot_payload)
+ print("The response of SnippetSnapshotsApi->save_snippet_snapshot:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetSnapshotsApi->save_snippet_snapshot: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **save_snippet_snapshot_payload** | [**SaveSnippetSnapshotPayload**](SaveSnippetSnapshotPayload.md)| The `Save Snippet Snapshots` resource definition | [optional]
+
+### Return type
+
+[**SaveSnippetSnapshotConfigResponse**](SaveSnippetSnapshotConfigResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_snippet_snapshot**
+> SnippetSnapshotSubscriberCompareResponse update_snippet_snapshot(snippet_snapshot_subscriber_compare_payload=snippet_snapshot_subscriber_compare_payload)
+
+Update Snippet Snapshots
+
+Update Snippet Snapshots.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_payload import SnippetSnapshotSubscriberComparePayload
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response import SnippetSnapshotSubscriberCompareResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetSnapshotsApi(api_client)
+ snippet_snapshot_subscriber_compare_payload = scm.config_setup.SnippetSnapshotSubscriberComparePayload() # SnippetSnapshotSubscriberComparePayload | The `Snippet Snapshots To Update` resource definition (optional)
+
+ try:
+ # Update Snippet Snapshots
+ api_response = api_instance.update_snippet_snapshot(snippet_snapshot_subscriber_compare_payload=snippet_snapshot_subscriber_compare_payload)
+ print("The response of SnippetSnapshotsApi->update_snippet_snapshot:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetSnapshotsApi->update_snippet_snapshot: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippet_snapshot_subscriber_compare_payload** | [**SnippetSnapshotSubscriberComparePayload**](SnippetSnapshotSubscriberComparePayload.md)| The `Snippet Snapshots To Update` resource definition | [optional]
+
+### Return type
+
+[**SnippetSnapshotSubscriberCompareResponse**](SnippetSnapshotSubscriberCompareResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/Snippets.md b/scm/config_setup/docs/Snippets.md
new file mode 100644
index 00000000..8b37e881
--- /dev/null
+++ b/scm/config_setup/docs/Snippets.md
@@ -0,0 +1,33 @@
+# Snippets
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | The description of the snippet | [optional]
+**id** | **str** | The UUID of the snippet | [readonly]
+**labels** | **List[str]** | Labels applied to the snippet | [optional]
+**name** | **str** | The name of the snippet |
+**type** | **str** | The snippet type | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.snippets import Snippets
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Snippets from a JSON string
+snippets_instance = Snippets.from_json(json)
+# print the JSON string representation of the object
+print(Snippets.to_json())
+
+# convert the object into a dict
+snippets_dict = snippets_instance.to_dict()
+# create an instance of Snippets from a dict
+snippets_from_dict = Snippets.from_dict(snippets_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SnippetsApi.md b/scm/config_setup/docs/SnippetsApi.md
new file mode 100644
index 00000000..2705944d
--- /dev/null
+++ b/scm/config_setup/docs/SnippetsApi.md
@@ -0,0 +1,433 @@
+# scm.config_setup.SnippetsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_snippet**](SnippetsApi.md#create_snippet) | **POST** /snippets | Create a snippet
+[**delete_snippet_by_id**](SnippetsApi.md#delete_snippet_by_id) | **DELETE** /snippets/{id} | Delete a snippet
+[**get_snippet_by_id**](SnippetsApi.md#get_snippet_by_id) | **GET** /snippets/{id} | Get a snippet
+[**list_snippets**](SnippetsApi.md#list_snippets) | **GET** /snippets | List snippets
+[**update_snippet_by_id**](SnippetsApi.md#update_snippet_by_id) | **PUT** /snippets/{id} | Update a snippet
+
+
+# **create_snippet**
+> Snippets create_snippet(snippets=snippets)
+
+Create a snippet
+
+Create a new snippet.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippets import Snippets
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetsApi(api_client)
+ snippets = scm.config_setup.Snippets() # Snippets | The `snippet` resource definition. (optional)
+
+ try:
+ # Create a snippet
+ api_response = api_instance.create_snippet(snippets=snippets)
+ print("The response of SnippetsApi->create_snippet:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetsApi->create_snippet: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippets** | [**Snippets**](Snippets.md)| The `snippet` resource definition. | [optional]
+
+### Return type
+
+[**Snippets**](Snippets.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_snippet_by_id**
+> delete_snippet_by_id(id)
+
+Delete a snippet
+
+Delete an existing snippet.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Delete a snippet
+ api_instance.delete_snippet_by_id(id)
+ except Exception as e:
+ print("Exception when calling SnippetsApi->delete_snippet_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_snippet_by_id**
+> Snippets get_snippet_by_id(id)
+
+Get a snippet
+
+Retrieve an existing snippet.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippets import Snippets
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Get a snippet
+ api_response = api_instance.get_snippet_by_id(id)
+ print("The response of SnippetsApi->get_snippet_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetsApi->get_snippet_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+[**Snippets**](Snippets.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_snippets**
+> SnippetsListResponse list_snippets(limit=limit, offset=offset, name=name)
+
+List snippets
+
+Retrieve a list of snippets.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippets_list_response import SnippetsListResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetsApi(api_client)
+ limit = 56 # int | The maximum number of resources to return (optional)
+ offset = 56 # int | The offset into the list of resources returned (optional)
+ name = 'name_example' # str | The name of the resource (optional)
+
+ try:
+ # List snippets
+ api_response = api_instance.list_snippets(limit=limit, offset=offset, name=name)
+ print("The response of SnippetsApi->list_snippets:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetsApi->list_snippets: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of resources to return | [optional]
+ **offset** | **int**| The offset into the list of resources returned | [optional]
+ **name** | **str**| The name of the resource | [optional]
+
+### Return type
+
+[**SnippetsListResponse**](SnippetsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_snippet_by_id**
+> Snippets update_snippet_by_id(id, snippets=snippets)
+
+Update a snippet
+
+Update an existing snippet.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippets import Snippets
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SnippetsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+ snippets = scm.config_setup.Snippets() # Snippets | The `snippet` resource definition. (optional)
+
+ try:
+ # Update a snippet
+ api_response = api_instance.update_snippet_by_id(id, snippets=snippets)
+ print("The response of SnippetsApi->update_snippet_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SnippetsApi->update_snippet_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+ **snippets** | [**Snippets**](Snippets.md)| The `snippet` resource definition. | [optional]
+
+### Return type
+
+[**Snippets**](Snippets.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/SnippetsListResponse.md b/scm/config_setup/docs/SnippetsListResponse.md
new file mode 100644
index 00000000..8caf54ce
--- /dev/null
+++ b/scm/config_setup/docs/SnippetsListResponse.md
@@ -0,0 +1,32 @@
+# SnippetsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[Snippets]**](Snippets.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.config_setup.models.snippets_list_response import SnippetsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SnippetsListResponse from a JSON string
+snippets_list_response_instance = SnippetsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(SnippetsListResponse.to_json())
+
+# convert the object into a dict
+snippets_list_response_dict = snippets_list_response_instance.to_dict()
+# create an instance of SnippetsListResponse from a dict
+snippets_list_response_from_dict = SnippetsListResponse.from_dict(snippets_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/SubscribedTenantsApi.md b/scm/config_setup/docs/SubscribedTenantsApi.md
new file mode 100644
index 00000000..e4a5cda9
--- /dev/null
+++ b/scm/config_setup/docs/SubscribedTenantsApi.md
@@ -0,0 +1,346 @@
+# scm.config_setup.SubscribedTenantsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_subscribed_tenant**](SubscribedTenantsApi.md#create_subscribed_tenant) | **POST** /subscribed-tenants | Create Subscribed Tenant
+[**delete_subscribed_tenant_by_snipped_id**](SubscribedTenantsApi.md#delete_subscribed_tenant_by_snipped_id) | **DELETE** /subscribed-tenants | Delete a subscribed tenant
+[**list_subscribed_tenants_by_id**](SubscribedTenantsApi.md#list_subscribed_tenants_by_id) | **GET** /subscribed-tenants/{id} | Get Subscribed Tenants
+[**update_subscribed_tenant_by_snippet_id**](SubscribedTenantsApi.md#update_subscribed_tenant_by_snippet_id) | **PUT** /subscribed-tenants | Update a subscribed tenant
+
+
+# **create_subscribed_tenant**
+> TenantTrustInfo create_subscribed_tenant(add_subscriber_request_payload_inner=add_subscriber_request_payload_inner)
+
+Create Subscribed Tenant
+
+Create Subscribed Tenant.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.add_subscriber_request_payload_inner import AddSubscriberRequestPayloadInner
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SubscribedTenantsApi(api_client)
+ add_subscriber_request_payload_inner = [scm.config_setup.AddSubscriberRequestPayloadInner()] # List[AddSubscriberRequestPayloadInner] | The `Subscribed Tenant` resource definition (optional)
+
+ try:
+ # Create Subscribed Tenant
+ api_response = api_instance.create_subscribed_tenant(add_subscriber_request_payload_inner=add_subscriber_request_payload_inner)
+ print("The response of SubscribedTenantsApi->create_subscribed_tenant:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SubscribedTenantsApi->create_subscribed_tenant: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **add_subscriber_request_payload_inner** | [**List[AddSubscriberRequestPayloadInner]**](AddSubscriberRequestPayloadInner.md)| The `Subscribed Tenant` resource definition | [optional]
+
+### Return type
+
+[**TenantTrustInfo**](TenantTrustInfo.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_subscribed_tenant_by_snipped_id**
+> delete_subscribed_tenant_by_snipped_id(snippet_id, tsgs)
+
+Delete a subscribed tenant
+
+Delete an existing subscribed tenant.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SubscribedTenantsApi(api_client)
+ snippet_id = 'snippet_id_example' # str | The ID of the snippet
+ tsgs = 'tsgs_example' # str | Comma-separated list of recipient TSG IDs
+
+ try:
+ # Delete a subscribed tenant
+ api_instance.delete_subscribed_tenant_by_snipped_id(snippet_id, tsgs)
+ except Exception as e:
+ print("Exception when calling SubscribedTenantsApi->delete_subscribed_tenant_by_snipped_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **snippet_id** | **str**| The ID of the snippet |
+ **tsgs** | **str**| Comma-separated list of recipient TSG IDs |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_subscribed_tenants_by_id**
+> List[SnippetShareInfo] list_subscribed_tenants_by_id(id)
+
+Get Subscribed Tenants
+
+Retrieve a list of subscribed tenants.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SubscribedTenantsApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Get Subscribed Tenants
+ api_response = api_instance.list_subscribed_tenants_by_id(id)
+ print("The response of SubscribedTenantsApi->list_subscribed_tenants_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SubscribedTenantsApi->list_subscribed_tenants_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+[**List[SnippetShareInfo]**](SnippetShareInfo.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_subscribed_tenant_by_snippet_id**
+> SubscriberPropertyPayload update_subscribed_tenant_by_snippet_id(subscriber_property_payload=subscriber_property_payload)
+
+Update a subscribed tenant
+
+Update an existing subscribed tenant.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.subscriber_property_payload import SubscriberPropertyPayload
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.SubscribedTenantsApi(api_client)
+ subscriber_property_payload = scm.config_setup.SubscriberPropertyPayload() # SubscriberPropertyPayload | The `subscribed tenant` resource definition. (optional)
+
+ try:
+ # Update a subscribed tenant
+ api_response = api_instance.update_subscribed_tenant_by_snippet_id(subscriber_property_payload=subscriber_property_payload)
+ print("The response of SubscribedTenantsApi->update_subscribed_tenant_by_snippet_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SubscribedTenantsApi->update_subscribed_tenant_by_snippet_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **subscriber_property_payload** | [**SubscriberPropertyPayload**](SubscriberPropertyPayload.md)| The `subscribed tenant` resource definition. | [optional]
+
+### Return type
+
+[**SubscriberPropertyPayload**](SubscriberPropertyPayload.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/SubscriberPropertyPayload.md b/scm/config_setup/docs/SubscriberPropertyPayload.md
new file mode 100644
index 00000000..5ec37bee
--- /dev/null
+++ b/scm/config_setup/docs/SubscriberPropertyPayload.md
@@ -0,0 +1,32 @@
+# SubscriberPropertyPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**var_property** | [**List[PropertyItem]**](PropertyItem.md) | | [optional]
+**snippet_id** | **str** | |
+**snippet_name** | **str** | |
+**tsg_id** | **str** | |
+
+## Example
+
+```python
+from scm.config_setup.models.subscriber_property_payload import SubscriberPropertyPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SubscriberPropertyPayload from a JSON string
+subscriber_property_payload_instance = SubscriberPropertyPayload.from_json(json)
+# print the JSON string representation of the object
+print(SubscriberPropertyPayload.to_json())
+
+# convert the object into a dict
+subscriber_property_payload_dict = subscriber_property_payload_instance.to_dict()
+# create an instance of SubscriberPropertyPayload from a dict
+subscriber_property_payload_from_dict = SubscriberPropertyPayload.from_dict(subscriber_property_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/TenantTrustInfo.md b/scm/config_setup/docs/TenantTrustInfo.md
new file mode 100644
index 00000000..4be942b7
--- /dev/null
+++ b/scm/config_setup/docs/TenantTrustInfo.md
@@ -0,0 +1,52 @@
+# TenantTrustInfo
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**created** | **datetime** | | [optional] [readonly]
+**created_by** | **str** | | [optional] [readonly]
+**current_status** | **str** | | [optional] [readonly]
+**donor_cluster** | **str** | | [optional] [readonly]
+**donor_msg_uuid** | **str** | | [optional] [readonly]
+**donor_project** | **str** | | [optional] [readonly]
+**donor_region** | **str** | | [optional] [readonly]
+**donor_tenant_id** | **str** | | [optional]
+**donor_tenant_name** | **str** | | [optional]
+**donor_trust_info_id** | **int** | | [optional] [readonly]
+**donor_tsg** | **str** | | [optional] [readonly]
+**error_details** | **str** | | [optional] [readonly]
+**last_updated** | **datetime** | | [optional] [readonly]
+**psk** | **str** | | [optional]
+**recipient_cluster** | **str** | | [optional] [readonly]
+**recipient_msg_uuid** | **str** | | [optional] [readonly]
+**recipient_project** | **str** | | [optional] [readonly]
+**recipient_region** | **str** | | [optional] [readonly]
+**recipient_tenant_id** | **str** | | [optional] [readonly]
+**recipient_tenant_name** | **str** | | [optional]
+**recipient_trust_info_id** | **int** | | [optional] [readonly]
+**recipient_tsg** | **str** | | [optional] [readonly]
+**trust_id** | **int** | | [optional]
+**updated_by** | **str** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TenantTrustInfo from a JSON string
+tenant_trust_info_instance = TenantTrustInfo.from_json(json)
+# print the JSON string representation of the object
+print(TenantTrustInfo.to_json())
+
+# convert the object into a dict
+tenant_trust_info_dict = tenant_trust_info_instance.to_dict()
+# create an instance of TenantTrustInfo from a dict
+tenant_trust_info_from_dict = TenantTrustInfo.from_dict(tenant_trust_info_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/TrustInfoWithSharedSnippets.md b/scm/config_setup/docs/TrustInfoWithSharedSnippets.md
new file mode 100644
index 00000000..1d440c82
--- /dev/null
+++ b/scm/config_setup/docs/TrustInfoWithSharedSnippets.md
@@ -0,0 +1,47 @@
+# TrustInfoWithSharedSnippets
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**created** | **datetime** | | [optional] [readonly]
+**donor_created** | **int** | | [optional] [readonly]
+**donor_snippet_file_id** | **int** | | [optional] [readonly]
+**donor_snippet_version** | **int** | | [optional] [readonly]
+**donor_tsg** | **str** | | [optional] [readonly]
+**error** | **str** | | [optional] [readonly]
+**id** | **int** | | [optional] [readonly]
+**last_updated** | **datetime** | | [optional] [readonly]
+**msg_uuid** | **str** | | [optional] [readonly]
+**recipient_paused_update** | **int** | | [optional] [readonly]
+**recipient_snippet_file_id** | **int** | | [optional] [readonly]
+**recipient_snippet_version** | **int** | | [optional] [readonly]
+**recipient_tsg** | **str** | | [optional] [readonly]
+**recipient_validate_before_update** | **int** | | [optional] [readonly]
+**shared_snippets** | [**List[SnippetShareInfo]**](SnippetShareInfo.md) | | [optional]
+**snippet_name** | **str** | | [optional] [readonly]
+**snippet_uuid** | **str** | | [optional] [readonly]
+**status** | **str** | | [optional] [readonly]
+**updated_by** | **str** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.trust_info_with_shared_snippets import TrustInfoWithSharedSnippets
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrustInfoWithSharedSnippets from a JSON string
+trust_info_with_shared_snippets_instance = TrustInfoWithSharedSnippets.from_json(json)
+# print the JSON string representation of the object
+print(TrustInfoWithSharedSnippets.to_json())
+
+# convert the object into a dict
+trust_info_with_shared_snippets_dict = trust_info_with_shared_snippets_instance.to_dict()
+# create an instance of TrustInfoWithSharedSnippets from a dict
+trust_info_with_shared_snippets_from_dict = TrustInfoWithSharedSnippets.from_dict(trust_info_with_shared_snippets_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/TrustInformationApi.md b/scm/config_setup/docs/TrustInformationApi.md
new file mode 100644
index 00000000..4da27ef4
--- /dev/null
+++ b/scm/config_setup/docs/TrustInformationApi.md
@@ -0,0 +1,92 @@
+# scm.config_setup.TrustInformationApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**list_trusted_tenants_with_snippets**](TrustInformationApi.md#list_trusted_tenants_with_snippets) | **GET** /trusted-tenants | Trusted Tenants With Snippets
+
+
+# **list_trusted_tenants_with_snippets**
+> List[TrustInfoWithSharedSnippets] list_trusted_tenants_with_snippets(type)
+
+Trusted Tenants With Snippets
+
+Retrieve a list of trusted tenants with snippets.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.trust_info_with_shared_snippets import TrustInfoWithSharedSnippets
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.TrustInformationApi(api_client)
+ type = 'type_example' # str | Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'.
+
+ try:
+ # Trusted Tenants With Snippets
+ api_response = api_instance.list_trusted_tenants_with_snippets(type)
+ print("The response of TrustInformationApi->list_trusted_tenants_with_snippets:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrustInformationApi->list_trusted_tenants_with_snippets: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **type** | **str**| Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. |
+
+### Return type
+
+[**List[TrustInfoWithSharedSnippets]**](TrustInfoWithSharedSnippets.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/TrustValidationsApi.md b/scm/config_setup/docs/TrustValidationsApi.md
new file mode 100644
index 00000000..9deb0db9
--- /dev/null
+++ b/scm/config_setup/docs/TrustValidationsApi.md
@@ -0,0 +1,93 @@
+# scm.config_setup.TrustValidationsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**validate_trust**](TrustValidationsApi.md#validate_trust) | **POST** /trust-validations | Validates Trust
+
+
+# **validate_trust**
+> TenantTrustInfo validate_trust(trusts_validation_payload=trusts_validation_payload)
+
+Validates Trust
+
+Validate trust.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+from scm.config_setup.models.trusts_validation_payload import TrustsValidationPayload
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.TrustValidationsApi(api_client)
+ trusts_validation_payload = scm.config_setup.TrustsValidationPayload() # TrustsValidationPayload | The `trust validation` resource definition (optional)
+
+ try:
+ # Validates Trust
+ api_response = api_instance.validate_trust(trusts_validation_payload=trusts_validation_payload)
+ print("The response of TrustValidationsApi->validate_trust:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrustValidationsApi->validate_trust: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **trusts_validation_payload** | [**TrustsValidationPayload**](TrustsValidationPayload.md)| The `trust validation` resource definition | [optional]
+
+### Return type
+
+[**TenantTrustInfo**](TenantTrustInfo.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/TrustedTenantOverview.md b/scm/config_setup/docs/TrustedTenantOverview.md
new file mode 100644
index 00000000..b9a8ed0c
--- /dev/null
+++ b/scm/config_setup/docs/TrustedTenantOverview.md
@@ -0,0 +1,30 @@
+# TrustedTenantOverview
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**publisher** | [**TrustedTenantOverviewPublisher**](TrustedTenantOverviewPublisher.md) | | [optional]
+**subscriber** | [**TrustedTenantOverviewPublisher**](TrustedTenantOverviewPublisher.md) | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.trusted_tenant_overview import TrustedTenantOverview
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrustedTenantOverview from a JSON string
+trusted_tenant_overview_instance = TrustedTenantOverview.from_json(json)
+# print the JSON string representation of the object
+print(TrustedTenantOverview.to_json())
+
+# convert the object into a dict
+trusted_tenant_overview_dict = trusted_tenant_overview_instance.to_dict()
+# create an instance of TrustedTenantOverview from a dict
+trusted_tenant_overview_from_dict = TrustedTenantOverview.from_dict(trusted_tenant_overview_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/TrustedTenantOverviewPublisher.md b/scm/config_setup/docs/TrustedTenantOverviewPublisher.md
new file mode 100644
index 00000000..a1534be5
--- /dev/null
+++ b/scm/config_setup/docs/TrustedTenantOverviewPublisher.md
@@ -0,0 +1,30 @@
+# TrustedTenantOverviewPublisher
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**pending** | **int** | | [optional] [readonly]
+**total** | **int** | | [optional] [readonly]
+
+## Example
+
+```python
+from scm.config_setup.models.trusted_tenant_overview_publisher import TrustedTenantOverviewPublisher
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrustedTenantOverviewPublisher from a JSON string
+trusted_tenant_overview_publisher_instance = TrustedTenantOverviewPublisher.from_json(json)
+# print the JSON string representation of the object
+print(TrustedTenantOverviewPublisher.to_json())
+
+# convert the object into a dict
+trusted_tenant_overview_publisher_dict = trusted_tenant_overview_publisher_instance.to_dict()
+# create an instance of TrustedTenantOverviewPublisher from a dict
+trusted_tenant_overview_publisher_from_dict = TrustedTenantOverviewPublisher.from_dict(trusted_tenant_overview_publisher_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/TrustedTenantsOverviewApi.md b/scm/config_setup/docs/TrustedTenantsOverviewApi.md
new file mode 100644
index 00000000..76b420a7
--- /dev/null
+++ b/scm/config_setup/docs/TrustedTenantsOverviewApi.md
@@ -0,0 +1,88 @@
+# scm.config_setup.TrustedTenantsOverviewApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**get_trusted_tenants_overview**](TrustedTenantsOverviewApi.md#get_trusted_tenants_overview) | **GET** /trusted-tenant-overview | Trusted Tenants Overview
+
+
+# **get_trusted_tenants_overview**
+> TrustedTenantOverview get_trusted_tenants_overview()
+
+Trusted Tenants Overview
+
+Overview of publishers and subscribers.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.trusted_tenant_overview import TrustedTenantOverview
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.TrustedTenantsOverviewApi(api_client)
+
+ try:
+ # Trusted Tenants Overview
+ api_response = api_instance.get_trusted_tenants_overview()
+ print("The response of TrustedTenantsOverviewApi->get_trusted_tenants_overview:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrustedTenantsOverviewApi->get_trusted_tenants_overview: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**TrustedTenantOverview**](TrustedTenantOverview.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/Trusts.md b/scm/config_setup/docs/Trusts.md
new file mode 100644
index 00000000..775ea195
--- /dev/null
+++ b/scm/config_setup/docs/Trusts.md
@@ -0,0 +1,33 @@
+# Trusts
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**donor_tenant_name** | **str** | | [optional]
+**psk** | **str** | | [optional]
+**recipient_tenant_name** | **str** | | [optional]
+**trust_id** | **int** | | [optional]
+**tsg** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.config_setup.models.trusts import Trusts
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Trusts from a JSON string
+trusts_instance = Trusts.from_json(json)
+# print the JSON string representation of the object
+print(Trusts.to_json())
+
+# convert the object into a dict
+trusts_dict = trusts_instance.to_dict()
+# create an instance of Trusts from a dict
+trusts_from_dict = Trusts.from_dict(trusts_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/TrustsApi.md b/scm/config_setup/docs/TrustsApi.md
new file mode 100644
index 00000000..2ed60294
--- /dev/null
+++ b/scm/config_setup/docs/TrustsApi.md
@@ -0,0 +1,177 @@
+# scm.config_setup.TrustsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_trust**](TrustsApi.md#create_trust) | **POST** /trusts | Create a trust
+[**delete_trust**](TrustsApi.md#delete_trust) | **DELETE** /trusts | Delete a Trust
+
+
+# **create_trust**
+> TenantTrustInfo create_trust(trusts=trusts)
+
+Create a trust
+
+Create a new trust.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+from scm.config_setup.models.trusts import Trusts
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.TrustsApi(api_client)
+ trusts = scm.config_setup.Trusts() # Trusts | The `trusts` resource definition (optional)
+
+ try:
+ # Create a trust
+ api_response = api_instance.create_trust(trusts=trusts)
+ print("The response of TrustsApi->create_trust:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrustsApi->create_trust: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **trusts** | [**Trusts**](Trusts.md)| The `trusts` resource definition | [optional]
+
+### Return type
+
+[**TenantTrustInfo**](TenantTrustInfo.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_trust**
+> delete_trust(trustids, type)
+
+Delete a Trust
+
+Delete an existing Trust.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.TrustsApi(api_client)
+ trustids = 'trustids_example' # str | Comma-separated list of trust IDs
+ type = 'type_example' # str | Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'.
+
+ try:
+ # Delete a Trust
+ api_instance.delete_trust(trustids, type)
+ except Exception as e:
+ print("Exception when calling TrustsApi->delete_trust: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **trustids** | **str**| Comma-separated list of trust IDs |
+ **type** | **str**| Specifies the type of the tenant that is trusted, either 'subscriber' or 'publisher'. |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/TrustsValidationPayload.md b/scm/config_setup/docs/TrustsValidationPayload.md
new file mode 100644
index 00000000..d403c535
--- /dev/null
+++ b/scm/config_setup/docs/TrustsValidationPayload.md
@@ -0,0 +1,33 @@
+# TrustsValidationPayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**donor_tenant_name** | **str** | |
+**psk** | **str** | |
+**recipient_tenant_name** | **str** | |
+**trust_id** | **int** | |
+**tsg** | **str** | |
+
+## Example
+
+```python
+from scm.config_setup.models.trusts_validation_payload import TrustsValidationPayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrustsValidationPayload from a JSON string
+trusts_validation_payload_instance = TrustsValidationPayload.from_json(json)
+# print the JSON string representation of the object
+print(TrustsValidationPayload.to_json())
+
+# convert the object into a dict
+trusts_validation_payload_dict = trusts_validation_payload_instance.to_dict()
+# create an instance of TrustsValidationPayload from a dict
+trusts_validation_payload_from_dict = TrustsValidationPayload.from_dict(trusts_validation_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/UsedFolders.md b/scm/config_setup/docs/UsedFolders.md
new file mode 100644
index 00000000..95026a10
--- /dev/null
+++ b/scm/config_setup/docs/UsedFolders.md
@@ -0,0 +1,30 @@
+# UsedFolders
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | | [optional]
+**name** | **str** | |
+
+## Example
+
+```python
+from scm.config_setup.models.used_folders import UsedFolders
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UsedFolders from a JSON string
+used_folders_instance = UsedFolders.from_json(json)
+# print the JSON string representation of the object
+print(UsedFolders.to_json())
+
+# convert the object into a dict
+used_folders_dict = used_folders_instance.to_dict()
+# create an instance of UsedFolders from a dict
+used_folders_from_dict = UsedFolders.from_dict(used_folders_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/Variables.md b/scm/config_setup/docs/Variables.md
new file mode 100644
index 00000000..eefc6b7f
--- /dev/null
+++ b/scm/config_setup/docs/Variables.md
@@ -0,0 +1,37 @@
+# Variables
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | The description of the variable | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the variable | [readonly]
+**name** | **str** | The name of the variable |
+**overridden** | **bool** | Is the variable overridden? | [optional] [readonly]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**type** | **str** | The variable type |
+**value** | **object** | The value of the variable |
+
+## Example
+
+```python
+from scm.config_setup.models.variables import Variables
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Variables from a JSON string
+variables_instance = Variables.from_json(json)
+# print the JSON string representation of the object
+print(Variables.to_json())
+
+# convert the object into a dict
+variables_dict = variables_instance.to_dict()
+# create an instance of Variables from a dict
+variables_from_dict = Variables.from_dict(variables_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/docs/VariablesApi.md b/scm/config_setup/docs/VariablesApi.md
new file mode 100644
index 00000000..0867249d
--- /dev/null
+++ b/scm/config_setup/docs/VariablesApi.md
@@ -0,0 +1,445 @@
+# scm.config_setup.VariablesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/setup/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_variable**](VariablesApi.md#create_variable) | **POST** /variables | Create a variable
+[**delete_variable_by_id**](VariablesApi.md#delete_variable_by_id) | **DELETE** /variables/{id} | Delete a variable
+[**get_variable_by_id**](VariablesApi.md#get_variable_by_id) | **GET** /variables/{id} | Get a variables
+[**list_variables**](VariablesApi.md#list_variables) | **GET** /variables | List variables
+[**update_variable_by_id**](VariablesApi.md#update_variable_by_id) | **PUT** /variables/{id} | Update a variable
+
+
+# **create_variable**
+> Variables create_variable(folder=folder, snippet=snippet, device=device, variables=variables)
+
+Create a variable
+
+Create a new variable.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.variables import Variables
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.VariablesApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ variables = scm.config_setup.Variables() # Variables | The `variable` resource definition. (optional)
+
+ try:
+ # Create a variable
+ api_response = api_instance.create_variable(folder=folder, snippet=snippet, device=device, variables=variables)
+ print("The response of VariablesApi->create_variable:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VariablesApi->create_variable: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **variables** | [**Variables**](Variables.md)| The `variable` resource definition. | [optional]
+
+### Return type
+
+[**Variables**](Variables.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_variable_by_id**
+> delete_variable_by_id(id)
+
+Delete a variable
+
+Delete an existing variable.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.VariablesApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Delete a variable
+ api_instance.delete_variable_by_id(id)
+ except Exception as e:
+ print("Exception when calling VariablesApi->delete_variable_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_variable_by_id**
+> Variables get_variable_by_id(id)
+
+Get a variables
+
+Retrieve an existing variable.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.variables import Variables
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.VariablesApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+
+ try:
+ # Get a variables
+ api_response = api_instance.get_variable_by_id(id)
+ print("The response of VariablesApi->get_variable_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VariablesApi->get_variable_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+
+### Return type
+
+[**Variables**](Variables.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_variables**
+> VariablesListResponse list_variables(limit=limit, offset=offset, name=name, folder=folder, snippet=snippet, device=device)
+
+List variables
+
+Retrieve a list of variables.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.variables_list_response import VariablesListResponse
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.VariablesApi(api_client)
+ limit = 56 # int | The maximum number of resources to return (optional)
+ offset = 56 # int | The offset into the list of resources returned (optional)
+ name = 'name_example' # str | The name of the resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List variables
+ api_response = api_instance.list_variables(limit=limit, offset=offset, name=name, folder=folder, snippet=snippet, device=device)
+ print("The response of VariablesApi->list_variables:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VariablesApi->list_variables: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of resources to return | [optional]
+ **offset** | **int**| The offset into the list of resources returned | [optional]
+ **name** | **str**| The name of the resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**VariablesListResponse**](VariablesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_variable_by_id**
+> Variables update_variable_by_id(id, variables=variables)
+
+Update a variable
+
+Update an existing variable.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.config_setup
+from scm.config_setup.models.variables import Variables
+from scm.config_setup.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/setup/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.config_setup.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/setup/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.config_setup.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.config_setup.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.config_setup.VariablesApi(api_client)
+ id = 'id_example' # str | The UUID of the resource
+ variables = scm.config_setup.Variables() # Variables | The `variable` resource definition. (optional)
+
+ try:
+ # Update a variable
+ api_response = api_instance.update_variable_by_id(id, variables=variables)
+ print("The response of VariablesApi->update_variable_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VariablesApi->update_variable_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the resource |
+ **variables** | [**Variables**](Variables.md)| The `variable` resource definition. | [optional]
+
+### Return type
+
+[**Variables**](Variables.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/config_setup/docs/VariablesListResponse.md b/scm/config_setup/docs/VariablesListResponse.md
new file mode 100644
index 00000000..5b16b8a6
--- /dev/null
+++ b/scm/config_setup/docs/VariablesListResponse.md
@@ -0,0 +1,32 @@
+# VariablesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[Variables]**](Variables.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.config_setup.models.variables_list_response import VariablesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of VariablesListResponse from a JSON string
+variables_list_response_instance = VariablesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(VariablesListResponse.to_json())
+
+# convert the object into a dict
+variables_list_response_dict = variables_list_response_instance.to_dict()
+# create an instance of VariablesListResponse from a dict
+variables_list_response_from_dict = VariablesListResponse.from_dict(variables_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/config_setup/exceptions.py b/scm/config_setup/exceptions.py
new file mode 100644
index 00000000..589d6fbf
--- /dev/null
+++ b/scm/config_setup/exceptions.py
@@ -0,0 +1,200 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+from typing import Any, Optional
+from typing_extensions import Self
+
+class OpenApiException(Exception):
+ """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+ def __init__(self, msg, path_to_item=None, valid_classes=None,
+ key_type=None) -> None:
+ """ Raises an exception for TypeErrors
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list): a list of keys an indices to get to the
+ current_item
+ None if unset
+ valid_classes (tuple): the primitive classes that current item
+ should be an instance of
+ None if unset
+ key_type (bool): False if our value is a value in a dict
+ True if it is a key in a dict
+ False if our item is an item in a list
+ None if unset
+ """
+ self.path_to_item = path_to_item
+ self.valid_classes = valid_classes
+ self.key_type = key_type
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list) the path to the exception in the
+ received_data dict. None if unset
+ """
+
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Raised when an attribute reference or assignment fails.
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+ def __init__(
+ self,
+ status=None,
+ reason=None,
+ http_resp=None,
+ *,
+ body: Optional[str] = None,
+ data: Optional[Any] = None,
+ ) -> None:
+ self.status = status
+ self.reason = reason
+ self.body = body
+ self.data = data
+ self.headers = None
+
+ if http_resp:
+ if self.status is None:
+ self.status = http_resp.status
+ if self.reason is None:
+ self.reason = http_resp.reason
+ if self.body is None:
+ try:
+ self.body = http_resp.data.decode('utf-8')
+ except Exception:
+ pass
+ self.headers = http_resp.getheaders()
+
+ @classmethod
+ def from_response(
+ cls,
+ *,
+ http_resp,
+ body: Optional[str],
+ data: Optional[Any],
+ ) -> Self:
+ if http_resp.status == 400:
+ raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 401:
+ raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 403:
+ raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 404:
+ raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+ if 500 <= http_resp.status <= 599:
+ raise ServiceException(http_resp=http_resp, body=body, data=data)
+ raise ApiException(http_resp=http_resp, body=body, data=data)
+
+ def __str__(self):
+ """Custom error messages for exception"""
+ error_message = "({0})\n"\
+ "Reason: {1}\n".format(self.status, self.reason)
+ if self.headers:
+ error_message += "HTTP response headers: {0}\n".format(
+ self.headers)
+
+ if self.data or self.body:
+ error_message += "HTTP response body: {0}\n".format(self.data or self.body)
+
+ return error_message
+
+
+class BadRequestException(ApiException):
+ pass
+
+
+class NotFoundException(ApiException):
+ pass
+
+
+class UnauthorizedException(ApiException):
+ pass
+
+
+class ForbiddenException(ApiException):
+ pass
+
+
+class ServiceException(ApiException):
+ pass
+
+
+def render_path(path_to_item):
+ """Returns a string representation of a path"""
+ result = ""
+ for pth in path_to_item:
+ if isinstance(pth, int):
+ result += "[{0}]".format(pth)
+ else:
+ result += "['{0}']".format(pth)
+ return result
diff --git a/scm/config_setup/models/__init__.py b/scm/config_setup/models/__init__.py
new file mode 100644
index 00000000..17943f44
--- /dev/null
+++ b/scm/config_setup/models/__init__.py
@@ -0,0 +1,67 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+# import models into model package
+from scm.config_setup.models.add_subscriber_request_payload_inner import AddSubscriberRequestPayloadInner
+from scm.config_setup.models.common_snippet_snapshot_payload import CommonSnippetSnapshotPayload
+from scm.config_setup.models.compare_snippet_snapshot_config_payload import CompareSnippetSnapshotConfigPayload
+from scm.config_setup.models.compare_tlo_payload import CompareTloPayload
+from scm.config_setup.models.deleted_subscriber import DeletedSubscriber
+from scm.config_setup.models.devices import Devices
+from scm.config_setup.models.devices_available_licensess_inner import DevicesAvailableLicensessInner
+from scm.config_setup.models.devices_installed_licenses_inner import DevicesInstalledLicensesInner
+from scm.config_setup.models.devices_put import DevicesPut
+from scm.config_setup.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.config_setup.models.folders import Folders
+from scm.config_setup.models.folders_list_response import FoldersListResponse
+from scm.config_setup.models.generic_error import GenericError
+from scm.config_setup.models.labels import Labels
+from scm.config_setup.models.labels_list_response import LabelsListResponse
+from scm.config_setup.models.property_item import PropertyItem
+from scm.config_setup.models.save_snippet_snapshot_config_response import SaveSnippetSnapshotConfigResponse
+from scm.config_setup.models.save_snippet_snapshot_config_response_result import SaveSnippetSnapshotConfigResponseResult
+from scm.config_setup.models.save_snippet_snapshot_payload import SaveSnippetSnapshotPayload
+from scm.config_setup.models.snippet_audit_history import SnippetAuditHistory
+from scm.config_setup.models.snippet_audit_payload import SnippetAuditPayload
+from scm.config_setup.models.snippet_categories import SnippetCategories
+from scm.config_setup.models.snippet_categories_list_response import SnippetCategoriesListResponse
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from scm.config_setup.models.snippet_share_load_payload import SnippetShareLoadPayload
+from scm.config_setup.models.snippet_share_property import SnippetShareProperty
+from scm.config_setup.models.snippet_share_upload_payload import SnippetShareUploadPayload
+from scm.config_setup.models.snippet_snapshot_compare_entry import SnippetSnapshotCompareEntry
+from scm.config_setup.models.snippet_snapshot_diff_response import SnippetSnapshotDiffResponse
+from scm.config_setup.models.snippet_snapshot_diff_response_after import SnippetSnapshotDiffResponseAfter
+from scm.config_setup.models.snippet_snapshot_diff_response_before import SnippetSnapshotDiffResponseBefore
+from scm.config_setup.models.snippet_snapshot_load_snippet_payload import SnippetSnapshotLoadSnippetPayload
+from scm.config_setup.models.snippet_snapshot_load_snippet_response import SnippetSnapshotLoadSnippetResponse
+from scm.config_setup.models.snippet_snapshot_publish_request import SnippetSnapshotPublishRequest
+from scm.config_setup.models.snippet_snapshot_publish_response import SnippetSnapshotPublishResponse
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_payload import SnippetSnapshotSubscriberComparePayload
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response import SnippetSnapshotSubscriberCompareResponse
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response_publisher import SnippetSnapshotSubscriberCompareResponsePublisher
+from scm.config_setup.models.snippets import Snippets
+from scm.config_setup.models.snippets_list_response import SnippetsListResponse
+from scm.config_setup.models.subscriber_property_payload import SubscriberPropertyPayload
+from scm.config_setup.models.tenant_trust_info import TenantTrustInfo
+from scm.config_setup.models.trust_info_with_shared_snippets import TrustInfoWithSharedSnippets
+from scm.config_setup.models.trusted_tenant_overview import TrustedTenantOverview
+from scm.config_setup.models.trusted_tenant_overview_publisher import TrustedTenantOverviewPublisher
+from scm.config_setup.models.trusts import Trusts
+from scm.config_setup.models.trusts_validation_payload import TrustsValidationPayload
+from scm.config_setup.models.used_folders import UsedFolders
+from scm.config_setup.models.variables import Variables
+from scm.config_setup.models.variables_list_response import VariablesListResponse
diff --git a/scm/config_setup/models/add_subscriber_request_payload_inner.py b/scm/config_setup/models/add_subscriber_request_payload_inner.py
new file mode 100644
index 00000000..e769d915
--- /dev/null
+++ b/scm/config_setup/models/add_subscriber_request_payload_inner.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AddSubscriberRequestPayloadInner(BaseModel):
+ """
+ AddSubscriberRequestPayloadInner
+ """ # noqa: E501
+ snippet_id: StrictStr
+ snippet_name: StrictStr
+ tsg_id: StrictStr
+ __properties: ClassVar[List[str]] = ["snippet_id", "snippet_name", "tsg_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AddSubscriberRequestPayloadInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AddSubscriberRequestPayloadInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "snippet_id": obj.get("snippet_id"),
+ "snippet_name": obj.get("snippet_name"),
+ "tsg_id": obj.get("tsg_id")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/common_snippet_snapshot_payload.py b/scm/config_setup/models/common_snippet_snapshot_payload.py
new file mode 100644
index 00000000..1d4443fa
--- /dev/null
+++ b/scm/config_setup/models/common_snippet_snapshot_payload.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CommonSnippetSnapshotPayload(BaseModel):
+ """
+ CommonSnippetSnapshotPayload
+ """ # noqa: E501
+ id: Optional[StrictStr] = None
+ keep_local: Optional[StrictBool] = None
+ __properties: ClassVar[List[str]] = ["id", "keep_local"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CommonSnippetSnapshotPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CommonSnippetSnapshotPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "keep_local": obj.get("keep_local")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/compare_snippet_snapshot_config_payload.py b/scm/config_setup/models/compare_snippet_snapshot_config_payload.py
new file mode 100644
index 00000000..5d42300b
--- /dev/null
+++ b/scm/config_setup/models/compare_snippet_snapshot_config_payload.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompareSnippetSnapshotConfigPayload(BaseModel):
+ """
+ CompareSnippetSnapshotConfigPayload
+ """ # noqa: E501
+ comparing_version: StrictInt
+ id: StrictStr
+ version: StrictInt
+ __properties: ClassVar[List[str]] = ["comparing_version", "id", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CompareSnippetSnapshotConfigPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CompareSnippetSnapshotConfigPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "comparing_version": obj.get("comparing_version"),
+ "id": obj.get("id"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/compare_tlo_payload.py b/scm/config_setup/models/compare_tlo_payload.py
new file mode 100644
index 00000000..992376a0
--- /dev/null
+++ b/scm/config_setup/models/compare_tlo_payload.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CompareTloPayload(BaseModel):
+ """
+ CompareTloPayload
+ """ # noqa: E501
+ comparing_version: Optional[StrictInt] = None
+ object_id: StrictStr
+ snippet_id: StrictStr
+ version: StrictInt
+ __properties: ClassVar[List[str]] = ["comparing_version", "object_id", "snippet_id", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CompareTloPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CompareTloPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "comparing_version": obj.get("comparing_version"),
+ "object_id": obj.get("object_id"),
+ "snippet_id": obj.get("snippet_id"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/deleted_subscriber.py b/scm/config_setup/models/deleted_subscriber.py
new file mode 100644
index 00000000..f6cdee0b
--- /dev/null
+++ b/scm/config_setup/models/deleted_subscriber.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeletedSubscriber(BaseModel):
+ """
+ DeletedSubscriber
+ """ # noqa: E501
+ details: Optional[StrictStr] = None
+ info: Optional[SnippetShareInfo] = None
+ status: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["details", "info", "status"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of DeletedSubscriber from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of info
+ if self.info:
+ _dict['info'] = self.info.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of DeletedSubscriber from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "details": obj.get("details"),
+ "info": SnippetShareInfo.from_dict(obj["info"]) if obj.get("info") is not None else None,
+ "status": obj.get("status")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/devices.py b/scm/config_setup/models/devices.py
new file mode 100644
index 00000000..b4cc3bcc
--- /dev/null
+++ b/scm/config_setup/models/devices.py
@@ -0,0 +1,255 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.devices_available_licensess_inner import DevicesAvailableLicensessInner
+from scm.config_setup.models.devices_installed_licenses_inner import DevicesInstalledLicensesInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Devices(BaseModel):
+ """
+ Devices
+ """ # noqa: E501
+ anti_virus_version: Optional[StrictStr] = None
+ app_release_date: Optional[StrictStr] = None
+ app_version: Optional[StrictStr] = None
+ av_release_date: Optional[StrictStr] = None
+ available_licensess: Optional[List[DevicesAvailableLicensessInner]] = None
+ connected_since: Optional[datetime] = None
+ description: Optional[StrictStr] = Field(default=None, description="The description of the device")
+ dev_cert_detail: Optional[StrictStr] = None
+ dev_cert_expiry_date: Optional[StrictStr] = None
+ display_name: Optional[StrictStr] = Field(default=None, description="The display name of the device")
+ family: Optional[StrictStr] = Field(default=None, description="The product family of the device")
+ folder: StrictStr = Field(description="The folder containing the device")
+ gp_client_verion: Optional[StrictStr] = None
+ gp_data_version: Optional[StrictStr] = None
+ ha_peer_serial: Optional[StrictStr] = None
+ ha_peer_state: Optional[StrictStr] = None
+ ha_state: Optional[StrictStr] = None
+ hostname: Optional[StrictStr] = Field(default=None, description="The hostname of the device")
+ id: StrictStr = Field(description="The UUID of the device")
+ installed_licenses: Optional[List[DevicesInstalledLicensesInner]] = None
+ iot_release_date: Optional[StrictStr] = None
+ iot_version: Optional[StrictStr] = None
+ ip_v6_address: Optional[StrictStr] = Field(default=None, description="The IPv6 address of the device", alias="ipV6_address")
+ ip_address: Optional[StrictStr] = Field(default=None, description="The IPv4 address of the device")
+ is_connected: Optional[StrictBool] = None
+ labels: Optional[List[StrictStr]] = Field(default=None, description="Labels assigned to the device")
+ license_match: Optional[StrictBool] = None
+ log_db_version: Optional[StrictStr] = None
+ mac_address: Optional[StrictStr] = Field(default=None, description="The MAC address of the device")
+ model: Optional[StrictStr] = Field(default=None, description="The model of the device")
+ name: StrictStr = Field(description="The name of the device")
+ snippets: Optional[List[StrictStr]] = Field(default=None, description="Snippets associated with the device")
+ software_version: Optional[StrictStr] = None
+ threat_release_date: Optional[StrictStr] = None
+ threat_version: Optional[StrictStr] = None
+ uptime: Optional[StrictStr] = None
+ url_db_type: Optional[StrictStr] = None
+ url_db_ver: Optional[StrictStr] = None
+ vm_state: Optional[StrictStr] = None
+ wf_release_date: Optional[StrictStr] = None
+ wf_ver: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["anti_virus_version", "app_release_date", "app_version", "av_release_date", "available_licensess", "connected_since", "description", "dev_cert_detail", "dev_cert_expiry_date", "display_name", "family", "folder", "gp_client_verion", "gp_data_version", "ha_peer_serial", "ha_peer_state", "ha_state", "hostname", "id", "installed_licenses", "iot_release_date", "iot_version", "ipV6_address", "ip_address", "is_connected", "labels", "license_match", "log_db_version", "mac_address", "model", "name", "snippets", "software_version", "threat_release_date", "threat_version", "uptime", "url_db_type", "url_db_ver", "vm_state", "wf_release_date", "wf_ver"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Devices from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "anti_virus_version",
+ "app_release_date",
+ "app_version",
+ "av_release_date",
+ "available_licensess",
+ "connected_since",
+ "dev_cert_detail",
+ "dev_cert_expiry_date",
+ "family",
+ "gp_client_verion",
+ "gp_data_version",
+ "ha_peer_serial",
+ "ha_peer_state",
+ "ha_state",
+ "hostname",
+ "id",
+ "installed_licenses",
+ "iot_release_date",
+ "iot_version",
+ "ip_v6_address",
+ "ip_address",
+ "is_connected",
+ "license_match",
+ "log_db_version",
+ "mac_address",
+ "model",
+ "software_version",
+ "threat_release_date",
+ "threat_version",
+ "uptime",
+ "url_db_type",
+ "url_db_ver",
+ "vm_state",
+ "wf_release_date",
+ "wf_ver",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in available_licensess (list)
+ _items = []
+ if self.available_licensess:
+ for _item_available_licensess in self.available_licensess:
+ if _item_available_licensess:
+ _items.append(_item_available_licensess.to_dict())
+ _dict['available_licensess'] = _items
+ # override the default output from pydantic by calling `to_dict()` of each item in installed_licenses (list)
+ _items = []
+ if self.installed_licenses:
+ for _item_installed_licenses in self.installed_licenses:
+ if _item_installed_licenses:
+ _items.append(_item_installed_licenses.to_dict())
+ _dict['installed_licenses'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Devices from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "anti_virus_version": obj.get("anti_virus_version"),
+ "app_release_date": obj.get("app_release_date"),
+ "app_version": obj.get("app_version"),
+ "av_release_date": obj.get("av_release_date"),
+ "available_licensess": [DevicesAvailableLicensessInner.from_dict(_item) for _item in obj["available_licensess"]] if obj.get("available_licensess") is not None else None,
+ "connected_since": obj.get("connected_since"),
+ "description": obj.get("description"),
+ "dev_cert_detail": obj.get("dev_cert_detail"),
+ "dev_cert_expiry_date": obj.get("dev_cert_expiry_date"),
+ "display_name": obj.get("display_name"),
+ "family": obj.get("family"),
+ "folder": obj.get("folder"),
+ "gp_client_verion": obj.get("gp_client_verion"),
+ "gp_data_version": obj.get("gp_data_version"),
+ "ha_peer_serial": obj.get("ha_peer_serial"),
+ "ha_peer_state": obj.get("ha_peer_state"),
+ "ha_state": obj.get("ha_state"),
+ "hostname": obj.get("hostname"),
+ "id": obj.get("id"),
+ "installed_licenses": [DevicesInstalledLicensesInner.from_dict(_item) for _item in obj["installed_licenses"]] if obj.get("installed_licenses") is not None else None,
+ "iot_release_date": obj.get("iot_release_date"),
+ "iot_version": obj.get("iot_version"),
+ "ipV6_address": obj.get("ipV6_address"),
+ "ip_address": obj.get("ip_address"),
+ "is_connected": obj.get("is_connected"),
+ "labels": obj.get("labels"),
+ "license_match": obj.get("license_match"),
+ "log_db_version": obj.get("log_db_version"),
+ "mac_address": obj.get("mac_address"),
+ "model": obj.get("model"),
+ "name": obj.get("name"),
+ "snippets": obj.get("snippets"),
+ "software_version": obj.get("software_version"),
+ "threat_release_date": obj.get("threat_release_date"),
+ "threat_version": obj.get("threat_version"),
+ "uptime": obj.get("uptime"),
+ "url_db_type": obj.get("url_db_type"),
+ "url_db_ver": obj.get("url_db_ver"),
+ "vm_state": obj.get("vm_state"),
+ "wf_release_date": obj.get("wf_release_date"),
+ "wf_ver": obj.get("wf_ver")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/devices_available_licensess_inner.py b/scm/config_setup/models/devices_available_licensess_inner.py
new file mode 100644
index 00000000..64fb6e32
--- /dev/null
+++ b/scm/config_setup/models/devices_available_licensess_inner.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import date
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DevicesAvailableLicensessInner(BaseModel):
+ """
+ DevicesAvailableLicensessInner
+ """ # noqa: E501
+ authcode: Optional[StrictStr] = None
+ expires: Optional[date] = None
+ feature: Optional[StrictStr] = None
+ issued: Optional[date] = None
+ __properties: ClassVar[List[str]] = ["authcode", "expires", "feature", "issued"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of DevicesAvailableLicensessInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "authcode",
+ "expires",
+ "feature",
+ "issued",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of DevicesAvailableLicensessInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authcode": obj.get("authcode"),
+ "expires": obj.get("expires"),
+ "feature": obj.get("feature"),
+ "issued": obj.get("issued")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/devices_installed_licenses_inner.py b/scm/config_setup/models/devices_installed_licenses_inner.py
new file mode 100644
index 00000000..2dee9a59
--- /dev/null
+++ b/scm/config_setup/models/devices_installed_licenses_inner.py
@@ -0,0 +1,107 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import date
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DevicesInstalledLicensesInner(BaseModel):
+ """
+ DevicesInstalledLicensesInner
+ """ # noqa: E501
+ authcode: Optional[StrictStr] = None
+ expired: Optional[StrictStr] = None
+ expires: Optional[StrictStr] = None
+ feature: Optional[StrictStr] = None
+ issued: Optional[date] = None
+ __properties: ClassVar[List[str]] = ["authcode", "expired", "expires", "feature", "issued"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of DevicesInstalledLicensesInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "authcode",
+ "expired",
+ "expires",
+ "feature",
+ "issued",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of DevicesInstalledLicensesInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authcode": obj.get("authcode"),
+ "expired": obj.get("expired"),
+ "expires": obj.get("expires"),
+ "feature": obj.get("feature"),
+ "issued": obj.get("issued")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/devices_put.py b/scm/config_setup/models/devices_put.py
new file mode 100644
index 00000000..d7e7f02e
--- /dev/null
+++ b/scm/config_setup/models/devices_put.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DevicesPut(BaseModel):
+ """
+ DevicesPut
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default=None, description="The description of the device")
+ display_name: Optional[StrictStr] = Field(default=None, description="The display name of the device")
+ folder: Optional[StrictStr] = Field(default=None, description="The folder containing the device")
+ labels: Optional[List[StrictStr]] = Field(default=None, description="Labels assigned to the device")
+ snippets: Optional[List[StrictStr]] = Field(default=None, description="Snippets associated with the device")
+ __properties: ClassVar[List[str]] = ["description", "display_name", "folder", "labels", "snippets"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of DevicesPut from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of DevicesPut from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "display_name": obj.get("display_name"),
+ "folder": obj.get("folder"),
+ "labels": obj.get("labels"),
+ "snippets": obj.get("snippets")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/error_detail_cause_info.py b/scm/config_setup/models/error_detail_cause_info.py
new file mode 100644
index 00000000..fe1f50d6
--- /dev/null
+++ b/scm/config_setup/models/error_detail_cause_info.py
@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorDetailCauseInfo(BaseModel):
+ """
+ ErrorDetailCauseInfo
+ """ # noqa: E501
+ code: Optional[StrictStr] = None
+ details: Optional[Any] = None
+ help: Optional[StrictStr] = None
+ message: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["code", "details", "help", "message"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if details (nullable) is None
+ # and model_fields_set contains the field
+ if self.details is None and "details" in self.model_fields_set:
+ _dict['details'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "code": obj.get("code"),
+ "details": obj.get("details"),
+ "help": obj.get("help"),
+ "message": obj.get("message")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/folders.py b/scm/config_setup/models/folders.py
new file mode 100644
index 00000000..c6d52d22
--- /dev/null
+++ b/scm/config_setup/models/folders.py
@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Folders(BaseModel):
+ """
+ Folders
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default=None, description="The description of the folder")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the folder")
+ labels: Optional[List[StrictStr]] = Field(default=None, description="Labels assigned to the folder")
+ name: StrictStr = Field(description="The name of the folder")
+ parent: StrictStr = Field(description="The parent folder")
+ snippets: Optional[List[StrictStr]] = Field(default=None, description="Snippets associated with the folder")
+ __properties: ClassVar[List[str]] = ["description", "id", "labels", "name", "parent", "snippets"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Folders from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Folders from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "id": obj.get("id"),
+ "labels": obj.get("labels"),
+ "name": obj.get("name"),
+ "parent": obj.get("parent"),
+ "snippets": obj.get("snippets")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/folders_list_response.py b/scm/config_setup/models/folders_list_response.py
new file mode 100644
index 00000000..1de93984
--- /dev/null
+++ b/scm/config_setup/models/folders_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.config_setup.models.folders import Folders
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FoldersListResponse(BaseModel):
+ """
+ FoldersListResponse
+ """ # noqa: E501
+ data: List[Folders]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of FoldersListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of FoldersListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = Folders.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [Folders.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/generic_error.py b/scm/config_setup/models/generic_error.py
new file mode 100644
index 00000000..f5e40a4a
--- /dev/null
+++ b/scm/config_setup/models/generic_error.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.error_detail_cause_info import ErrorDetailCauseInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GenericError(BaseModel):
+ """
+ GenericError
+ """ # noqa: E501
+ errors: Optional[List[ErrorDetailCauseInfo]] = Field(default=None, alias="_errors")
+ request_id: Optional[StrictStr] = Field(default=None, alias="_request_id")
+ __properties: ClassVar[List[str]] = ["_errors", "_request_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GenericError from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+ _items = []
+ if self.errors:
+ for _item_errors in self.errors:
+ if _item_errors:
+ _items.append(_item_errors.to_dict())
+ _dict['_errors'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GenericError from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "_errors": [ErrorDetailCauseInfo.from_dict(_item) for _item in obj["_errors"]] if obj.get("_errors") is not None else None,
+ "_request_id": obj.get("_request_id")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/labels.py b/scm/config_setup/models/labels.py
new file mode 100644
index 00000000..61c68105
--- /dev/null
+++ b/scm/config_setup/models/labels.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Labels(BaseModel):
+ """
+ Labels
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default=None, description="The description of the label")
+ id: StrictStr = Field(description="The UUID of the label")
+ name: StrictStr = Field(description="The name of the label")
+ __properties: ClassVar[List[str]] = ["description", "id", "name"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Labels from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Labels from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "id": obj.get("id"),
+ "name": obj.get("name")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/labels_list_response.py b/scm/config_setup/models/labels_list_response.py
new file mode 100644
index 00000000..ac29ce31
--- /dev/null
+++ b/scm/config_setup/models/labels_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.config_setup.models.labels import Labels
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LabelsListResponse(BaseModel):
+ """
+ LabelsListResponse
+ """ # noqa: E501
+ data: List[Labels]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LabelsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LabelsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = Labels.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [Labels.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/property_item.py b/scm/config_setup/models/property_item.py
new file mode 100644
index 00000000..29ed1d0a
--- /dev/null
+++ b/scm/config_setup/models/property_item.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class PropertyItem(BaseModel):
+ """
+ PropertyItem
+ """ # noqa: E501
+ id: Optional[StrictInt] = None
+ name: Optional[StrictStr] = None
+ value: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["id", "name", "value"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of PropertyItem from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of PropertyItem from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "value": obj.get("value")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/save_snippet_snapshot_config_response.py b/scm/config_setup/models/save_snippet_snapshot_config_response.py
new file mode 100644
index 00000000..af03690d
--- /dev/null
+++ b/scm/config_setup/models/save_snippet_snapshot_config_response.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.save_snippet_snapshot_config_response_result import SaveSnippetSnapshotConfigResponseResult
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SaveSnippetSnapshotConfigResponse(BaseModel):
+ """
+ SaveSnippetSnapshotConfigResponse
+ """ # noqa: E501
+ result: Optional[SaveSnippetSnapshotConfigResponseResult] = None
+ status: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["result", "status"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SaveSnippetSnapshotConfigResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "status",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of result
+ if self.result:
+ _dict['result'] = self.result.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SaveSnippetSnapshotConfigResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "result": SaveSnippetSnapshotConfigResponseResult.from_dict(obj["result"]) if obj.get("result") is not None else None,
+ "status": obj.get("status")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/save_snippet_snapshot_config_response_result.py b/scm/config_setup/models/save_snippet_snapshot_config_response_result.py
new file mode 100644
index 00000000..d62a8f64
--- /dev/null
+++ b/scm/config_setup/models/save_snippet_snapshot_config_response_result.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SaveSnippetSnapshotConfigResponseResult(BaseModel):
+ """
+ SaveSnippetSnapshotConfigResponseResult
+ """ # noqa: E501
+ version: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SaveSnippetSnapshotConfigResponseResult from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SaveSnippetSnapshotConfigResponseResult from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/save_snippet_snapshot_payload.py b/scm/config_setup/models/save_snippet_snapshot_payload.py
new file mode 100644
index 00000000..b788b7d6
--- /dev/null
+++ b/scm/config_setup/models/save_snippet_snapshot_payload.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SaveSnippetSnapshotPayload(BaseModel):
+ """
+ SaveSnippetSnapshotPayload
+ """ # noqa: E501
+ description: StrictStr
+ id: StrictStr
+ __properties: ClassVar[List[str]] = ["description", "id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SaveSnippetSnapshotPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SaveSnippetSnapshotPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "id": obj.get("id")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_audit_history.py b/scm/config_setup/models/snippet_audit_history.py
new file mode 100644
index 00000000..313ab49c
--- /dev/null
+++ b/scm/config_setup/models/snippet_audit_history.py
@@ -0,0 +1,143 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetAuditHistory(BaseModel):
+ """
+ SnippetAuditHistory
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ created: Optional[datetime] = None
+ deleted: Optional[StrictInt] = None
+ details: Optional[StrictStr] = None
+ display: Optional[StrictInt] = None
+ donor_created: Optional[StrictInt] = None
+ donor_tenant_name: Optional[StrictStr] = None
+ donor_tsg: Optional[StrictStr] = None
+ id: Optional[StrictInt] = None
+ recipient_tenant_name: Optional[StrictStr] = None
+ recipient_tsg: Optional[StrictStr] = None
+ snippet_uuid: Optional[StrictStr] = None
+ user: Optional[StrictStr] = None
+ version: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["action", "created", "deleted", "details", "display", "donor_created", "donor_tenant_name", "donor_tsg", "id", "recipient_tenant_name", "recipient_tsg", "snippet_uuid", "user", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetAuditHistory from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "action",
+ "created",
+ "deleted",
+ "details",
+ "display",
+ "donor_created",
+ "donor_tenant_name",
+ "donor_tsg",
+ "id",
+ "recipient_tenant_name",
+ "recipient_tsg",
+ "snippet_uuid",
+ "user",
+ "version",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetAuditHistory from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "created": obj.get("created"),
+ "deleted": obj.get("deleted"),
+ "details": obj.get("details"),
+ "display": obj.get("display"),
+ "donor_created": obj.get("donor_created"),
+ "donor_tenant_name": obj.get("donor_tenant_name"),
+ "donor_tsg": obj.get("donor_tsg"),
+ "id": obj.get("id"),
+ "recipient_tenant_name": obj.get("recipient_tenant_name"),
+ "recipient_tsg": obj.get("recipient_tsg"),
+ "snippet_uuid": obj.get("snippet_uuid"),
+ "user": obj.get("user"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_audit_payload.py b/scm/config_setup/models/snippet_audit_payload.py
new file mode 100644
index 00000000..0a2d63af
--- /dev/null
+++ b/scm/config_setup/models/snippet_audit_payload.py
@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetAuditPayload(BaseModel):
+ """
+ SnippetAuditPayload
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ details: Optional[StrictStr] = None
+ donor_created: Optional[StrictInt] = None
+ donor_tenant_name: Optional[StrictStr] = None
+ donor_tsg: Optional[StrictStr] = None
+ recipient_tenant_name: Optional[StrictStr] = None
+ recipient_tsg: Optional[StrictStr] = None
+ snippet_uuid: Optional[StrictStr] = None
+ version: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["action", "details", "donor_created", "donor_tenant_name", "donor_tsg", "recipient_tenant_name", "recipient_tsg", "snippet_uuid", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetAuditPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetAuditPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "details": obj.get("details"),
+ "donor_created": obj.get("donor_created"),
+ "donor_tenant_name": obj.get("donor_tenant_name"),
+ "donor_tsg": obj.get("donor_tsg"),
+ "recipient_tenant_name": obj.get("recipient_tenant_name"),
+ "recipient_tsg": obj.get("recipient_tsg"),
+ "snippet_uuid": obj.get("snippet_uuid"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_categories.py b/scm/config_setup/models/snippet_categories.py
new file mode 100644
index 00000000..203e1471
--- /dev/null
+++ b/scm/config_setup/models/snippet_categories.py
@@ -0,0 +1,203 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.used_folders import UsedFolders
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetCategories(BaseModel):
+ """
+ SnippetCategories
+ """ # noqa: E501
+ created_in: Optional[datetime] = None
+ description: Optional[StrictStr] = None
+ display_name: Optional[StrictStr] = None
+ donor_created: Optional[StrictInt] = None
+ donor_snippet_file_id: Optional[StrictInt] = None
+ donor_snippet_version: Optional[StrictInt] = None
+ donor_tenant_id: Optional[StrictStr] = None
+ donor_tenant_name: Optional[StrictStr] = None
+ donor_tsg: Optional[StrictStr] = None
+ enable_prefix: Optional[StrictBool] = None
+ error: Optional[StrictStr] = None
+ folders: Optional[List[UsedFolders]] = None
+ id: StrictStr
+ labels: Optional[List[StrictStr]] = None
+ last_update: Optional[datetime] = None
+ msg_uuid: Optional[StrictStr] = None
+ name: StrictStr
+ prefix: Optional[StrictStr] = None
+ recipient_paused_update: Optional[StrictBool] = None
+ recipient_tenant_id: Optional[StrictStr] = None
+ recipient_tenant_name: Optional[StrictStr] = None
+ recipient_tsg: Optional[StrictStr] = None
+ recipient_validate_before_update: Optional[StrictBool] = None
+ shared_in: Optional[StrictStr] = None
+ snippet_uuid: Optional[StrictStr] = None
+ status: Optional[StrictStr] = None
+ type: Optional[StrictStr] = None
+ version: Optional[StrictInt] = None
+ __properties: ClassVar[List[str]] = ["created_in", "description", "display_name", "donor_created", "donor_snippet_file_id", "donor_snippet_version", "donor_tenant_id", "donor_tenant_name", "donor_tsg", "enable_prefix", "error", "folders", "id", "labels", "last_update", "msg_uuid", "name", "prefix", "recipient_paused_update", "recipient_tenant_id", "recipient_tenant_name", "recipient_tsg", "recipient_validate_before_update", "shared_in", "snippet_uuid", "status", "type", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetCategories from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "created_in",
+ "description",
+ "display_name",
+ "donor_created",
+ "donor_snippet_file_id",
+ "donor_snippet_version",
+ "donor_tenant_id",
+ "donor_tenant_name",
+ "donor_tsg",
+ "enable_prefix",
+ "error",
+ "id",
+ "last_update",
+ "msg_uuid",
+ "name",
+ "prefix",
+ "recipient_paused_update",
+ "recipient_tenant_id",
+ "recipient_tenant_name",
+ "recipient_tsg",
+ "recipient_validate_before_update",
+ "shared_in",
+ "snippet_uuid",
+ "status",
+ "type",
+ "version",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in folders (list)
+ _items = []
+ if self.folders:
+ for _item_folders in self.folders:
+ if _item_folders:
+ _items.append(_item_folders.to_dict())
+ _dict['folders'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetCategories from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "created_in": obj.get("created_in"),
+ "description": obj.get("description"),
+ "display_name": obj.get("display_name"),
+ "donor_created": obj.get("donor_created"),
+ "donor_snippet_file_id": obj.get("donor_snippet_file_id"),
+ "donor_snippet_version": obj.get("donor_snippet_version"),
+ "donor_tenant_id": obj.get("donor_tenant_id"),
+ "donor_tenant_name": obj.get("donor_tenant_name"),
+ "donor_tsg": obj.get("donor_tsg"),
+ "enable_prefix": obj.get("enable_prefix"),
+ "error": obj.get("error"),
+ "folders": [UsedFolders.from_dict(_item) for _item in obj["folders"]] if obj.get("folders") is not None else None,
+ "id": obj.get("id"),
+ "labels": obj.get("labels"),
+ "last_update": obj.get("last_update"),
+ "msg_uuid": obj.get("msg_uuid"),
+ "name": obj.get("name"),
+ "prefix": obj.get("prefix"),
+ "recipient_paused_update": obj.get("recipient_paused_update"),
+ "recipient_tenant_id": obj.get("recipient_tenant_id"),
+ "recipient_tenant_name": obj.get("recipient_tenant_name"),
+ "recipient_tsg": obj.get("recipient_tsg"),
+ "recipient_validate_before_update": obj.get("recipient_validate_before_update"),
+ "shared_in": obj.get("shared_in"),
+ "snippet_uuid": obj.get("snippet_uuid"),
+ "status": obj.get("status"),
+ "type": obj.get("type"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_categories_list_response.py b/scm/config_setup/models/snippet_categories_list_response.py
new file mode 100644
index 00000000..06c3a6eb
--- /dev/null
+++ b/scm/config_setup/models/snippet_categories_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.config_setup.models.snippet_categories import SnippetCategories
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetCategoriesListResponse(BaseModel):
+ """
+ SnippetCategoriesListResponse
+ """ # noqa: E501
+ data: List[SnippetCategories]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetCategoriesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetCategoriesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = SnippetCategories.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [SnippetCategories.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_share_info.py b/scm/config_setup/models/snippet_share_info.py
new file mode 100644
index 00000000..013c75df
--- /dev/null
+++ b/scm/config_setup/models/snippet_share_info.py
@@ -0,0 +1,181 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.snippet_share_property import SnippetShareProperty
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetShareInfo(BaseModel):
+ """
+ SnippetShareInfo
+ """ # noqa: E501
+ created: Optional[datetime] = None
+ donor_created: Optional[StrictInt] = None
+ donor_snippet_file_id: Optional[StrictInt] = None
+ donor_snippet_version: Optional[StrictInt] = None
+ donor_tenant_id: Optional[StrictStr] = None
+ donor_tenant_name: Optional[StrictStr] = None
+ donor_tsg: Optional[StrictStr] = None
+ error: Optional[StrictStr] = None
+ id: Optional[StrictInt] = None
+ last_updated: Optional[datetime] = None
+ msg_uuid: Optional[StrictStr] = None
+ properties: Optional[List[SnippetShareProperty]] = None
+ recipient_paused_update: Optional[StrictBool] = None
+ recipient_snippet_file_id: Optional[StrictInt] = None
+ recipient_snippet_version: Optional[StrictInt] = None
+ recipient_tenant_id: Optional[StrictStr] = None
+ recipient_tenant_name: Optional[StrictStr] = None
+ recipient_tsg: Optional[StrictStr] = None
+ recipient_validate_before_update: Optional[StrictBool] = None
+ snippet_name: Optional[StrictStr] = None
+ snippet_uuid: Optional[StrictStr] = None
+ status: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["created", "donor_created", "donor_snippet_file_id", "donor_snippet_version", "donor_tenant_id", "donor_tenant_name", "donor_tsg", "error", "id", "last_updated", "msg_uuid", "properties", "recipient_paused_update", "recipient_snippet_file_id", "recipient_snippet_version", "recipient_tenant_id", "recipient_tenant_name", "recipient_tsg", "recipient_validate_before_update", "snippet_name", "snippet_uuid", "status"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetShareInfo from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "created",
+ "donor_created",
+ "donor_snippet_file_id",
+ "donor_snippet_version",
+ "donor_tenant_id",
+ "donor_tenant_name",
+ "donor_tsg",
+ "error",
+ "id",
+ "last_updated",
+ "msg_uuid",
+ "recipient_paused_update",
+ "recipient_snippet_file_id",
+ "recipient_snippet_version",
+ "recipient_tenant_id",
+ "recipient_tenant_name",
+ "recipient_tsg",
+ "recipient_validate_before_update",
+ "snippet_name",
+ "snippet_uuid",
+ "status",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in properties (list)
+ _items = []
+ if self.properties:
+ for _item_properties in self.properties:
+ if _item_properties:
+ _items.append(_item_properties.to_dict())
+ _dict['properties'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetShareInfo from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "created": obj.get("created"),
+ "donor_created": obj.get("donor_created"),
+ "donor_snippet_file_id": obj.get("donor_snippet_file_id"),
+ "donor_snippet_version": obj.get("donor_snippet_version"),
+ "donor_tenant_id": obj.get("donor_tenant_id"),
+ "donor_tenant_name": obj.get("donor_tenant_name"),
+ "donor_tsg": obj.get("donor_tsg"),
+ "error": obj.get("error"),
+ "id": obj.get("id"),
+ "last_updated": obj.get("last_updated"),
+ "msg_uuid": obj.get("msg_uuid"),
+ "properties": [SnippetShareProperty.from_dict(_item) for _item in obj["properties"]] if obj.get("properties") is not None else None,
+ "recipient_paused_update": obj.get("recipient_paused_update"),
+ "recipient_snippet_file_id": obj.get("recipient_snippet_file_id"),
+ "recipient_snippet_version": obj.get("recipient_snippet_version"),
+ "recipient_tenant_id": obj.get("recipient_tenant_id"),
+ "recipient_tenant_name": obj.get("recipient_tenant_name"),
+ "recipient_tsg": obj.get("recipient_tsg"),
+ "recipient_validate_before_update": obj.get("recipient_validate_before_update"),
+ "snippet_name": obj.get("snippet_name"),
+ "snippet_uuid": obj.get("snippet_uuid"),
+ "status": obj.get("status")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_share_load_payload.py b/scm/config_setup/models/snippet_share_load_payload.py
new file mode 100644
index 00000000..51b8ccea
--- /dev/null
+++ b/scm/config_setup/models/snippet_share_load_payload.py
@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetShareLoadPayload(BaseModel):
+ """
+ SnippetShareLoadPayload
+ """ # noqa: E501
+ id: StrictStr
+ validation: Optional[StrictBool] = None
+ __properties: ClassVar[List[str]] = ["id", "validation"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetShareLoadPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if validation (nullable) is None
+ # and model_fields_set contains the field
+ if self.validation is None and "validation" in self.model_fields_set:
+ _dict['validation'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetShareLoadPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "validation": obj.get("validation")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_share_property.py b/scm/config_setup/models/snippet_share_property.py
new file mode 100644
index 00000000..ce60adf3
--- /dev/null
+++ b/scm/config_setup/models/snippet_share_property.py
@@ -0,0 +1,151 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetShareProperty(BaseModel):
+ """
+ SnippetShareProperty
+ """ # noqa: E501
+ created: Optional[datetime] = None
+ created_by: Optional[StrictStr] = None
+ donor_tenant: Optional[StrictStr] = None
+ donor_tsg: Optional[StrictStr] = None
+ error: Optional[StrictStr] = None
+ id: Optional[StrictInt] = None
+ msg_uuid: Optional[StrictStr] = None
+ property_name: Optional[StrictStr] = None
+ property_value: Optional[StrictStr] = None
+ recipient_tenant: Optional[StrictStr] = None
+ recipient_tsg: Optional[StrictStr] = None
+ snippet_name: Optional[StrictStr] = None
+ snippet_uuid: Optional[StrictStr] = None
+ status: Optional[StrictStr] = None
+ updated: Optional[datetime] = None
+ updated_by: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["created", "created_by", "donor_tenant", "donor_tsg", "error", "id", "msg_uuid", "property_name", "property_value", "recipient_tenant", "recipient_tsg", "snippet_name", "snippet_uuid", "status", "updated", "updated_by"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetShareProperty from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "created",
+ "created_by",
+ "donor_tenant",
+ "donor_tsg",
+ "error",
+ "id",
+ "msg_uuid",
+ "property_name",
+ "property_value",
+ "recipient_tenant",
+ "recipient_tsg",
+ "snippet_name",
+ "snippet_uuid",
+ "status",
+ "updated",
+ "updated_by",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetShareProperty from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "created": obj.get("created"),
+ "created_by": obj.get("created_by"),
+ "donor_tenant": obj.get("donor_tenant"),
+ "donor_tsg": obj.get("donor_tsg"),
+ "error": obj.get("error"),
+ "id": obj.get("id"),
+ "msg_uuid": obj.get("msg_uuid"),
+ "property_name": obj.get("property_name"),
+ "property_value": obj.get("property_value"),
+ "recipient_tenant": obj.get("recipient_tenant"),
+ "recipient_tsg": obj.get("recipient_tsg"),
+ "snippet_name": obj.get("snippet_name"),
+ "snippet_uuid": obj.get("snippet_uuid"),
+ "status": obj.get("status"),
+ "updated": obj.get("updated"),
+ "updated_by": obj.get("updated_by")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_share_upload_payload.py b/scm/config_setup/models/snippet_share_upload_payload.py
new file mode 100644
index 00000000..8f258136
--- /dev/null
+++ b/scm/config_setup/models/snippet_share_upload_payload.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetShareUploadPayload(BaseModel):
+ """
+ SnippetShareUploadPayload
+ """ # noqa: E501
+ id: StrictStr
+ pause_update: Optional[StrictBool] = None
+ validate_before_update: Optional[StrictBool] = None
+ __properties: ClassVar[List[str]] = ["id", "pause_update", "validate_before_update"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetShareUploadPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetShareUploadPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "pause_update": obj.get("pause_update"),
+ "validate_before_update": obj.get("validate_before_update")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_compare_entry.py b/scm/config_setup/models/snippet_snapshot_compare_entry.py
new file mode 100644
index 00000000..d1858e4f
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_compare_entry.py
@@ -0,0 +1,117 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotCompareEntry(BaseModel):
+ """
+ SnippetSnapshotCompareEntry
+ """ # noqa: E501
+ admin: Optional[StrictStr] = None
+ id: Optional[StrictStr] = None
+ loc: Optional[StrictStr] = None
+ loctype: Optional[StrictStr] = None
+ objectname: Optional[StrictStr] = None
+ objecttype: Optional[StrictStr] = None
+ operations: Optional[StrictStr] = None
+ timestamp: Optional[datetime] = None
+ __properties: ClassVar[List[str]] = ["admin", "id", "loc", "loctype", "objectname", "objecttype", "operations", "timestamp"]
+
+ @field_validator('operations')
+ def operations_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['edit', 'create']):
+ raise ValueError("must be one of enum values ('edit', 'create')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotCompareEntry from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "admin",
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotCompareEntry from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "admin": obj.get("admin"),
+ "id": obj.get("id"),
+ "loc": obj.get("loc"),
+ "loctype": obj.get("loctype"),
+ "objectname": obj.get("objectname"),
+ "objecttype": obj.get("objecttype"),
+ "operations": obj.get("operations"),
+ "timestamp": obj.get("timestamp")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_diff_response.py b/scm/config_setup/models/snippet_snapshot_diff_response.py
new file mode 100644
index 00000000..42974513
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_diff_response.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.snippet_snapshot_diff_response_after import SnippetSnapshotDiffResponseAfter
+from scm.config_setup.models.snippet_snapshot_diff_response_before import SnippetSnapshotDiffResponseBefore
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotDiffResponse(BaseModel):
+ """
+ SnippetSnapshotDiffResponse
+ """ # noqa: E501
+ after: Optional[SnippetSnapshotDiffResponseAfter] = None
+ before: Optional[SnippetSnapshotDiffResponseBefore] = None
+ __properties: ClassVar[List[str]] = ["after", "before"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotDiffResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of after
+ if self.after:
+ _dict['after'] = self.after.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of before
+ if self.before:
+ _dict['before'] = self.before.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotDiffResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "after": SnippetSnapshotDiffResponseAfter.from_dict(obj["after"]) if obj.get("after") is not None else None,
+ "before": SnippetSnapshotDiffResponseBefore.from_dict(obj["before"]) if obj.get("before") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_diff_response_after.py b/scm/config_setup/models/snippet_snapshot_diff_response_after.py
new file mode 100644
index 00000000..5d0a0408
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_diff_response_after.py
@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotDiffResponseAfter(BaseModel):
+ """
+ SnippetSnapshotDiffResponseAfter
+ """ # noqa: E501
+ ts: Optional[datetime] = Field(default=None, alias="@ts")
+ entry: Optional[List[Dict[str, Any]]] = None
+ __properties: ClassVar[List[str]] = ["@ts", "entry"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotDiffResponseAfter from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "ts",
+ "entry",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotDiffResponseAfter from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "@ts": obj.get("@ts"),
+ "entry": obj.get("entry")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_diff_response_before.py b/scm/config_setup/models/snippet_snapshot_diff_response_before.py
new file mode 100644
index 00000000..7a3b44ec
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_diff_response_before.py
@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotDiffResponseBefore(BaseModel):
+ """
+ SnippetSnapshotDiffResponseBefore
+ """ # noqa: E501
+ ts: Optional[datetime] = Field(default=None, alias="@ts")
+ entry: Optional[List[Dict[str, Any]]] = None
+ __properties: ClassVar[List[str]] = ["@ts", "entry"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotDiffResponseBefore from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotDiffResponseBefore from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "@ts": obj.get("@ts"),
+ "entry": obj.get("entry")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_load_snippet_payload.py b/scm/config_setup/models/snippet_snapshot_load_snippet_payload.py
new file mode 100644
index 00000000..830da438
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_load_snippet_payload.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotLoadSnippetPayload(BaseModel):
+ """
+ SnippetSnapshotLoadSnippetPayload
+ """ # noqa: E501
+ id: StrictStr
+ version: StrictStr
+ __properties: ClassVar[List[str]] = ["id", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotLoadSnippetPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotLoadSnippetPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_load_snippet_response.py b/scm/config_setup/models/snippet_snapshot_load_snippet_response.py
new file mode 100644
index 00000000..29c5248a
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_load_snippet_response.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotLoadSnippetResponse(BaseModel):
+ """
+ SnippetSnapshotLoadSnippetResponse
+ """ # noqa: E501
+ status: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["status"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotLoadSnippetResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotLoadSnippetResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "status": obj.get("status")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_publish_request.py b/scm/config_setup/models/snippet_snapshot_publish_request.py
new file mode 100644
index 00000000..d0729653
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_publish_request.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotPublishRequest(BaseModel):
+ """
+ SnippetSnapshotPublishRequest
+ """ # noqa: E501
+ id: Optional[StrictStr] = None
+ name: Optional[StrictStr] = None
+ tsgs: Optional[List[StrictStr]] = None
+ validation: Optional[StrictBool] = None
+ version: Optional[StrictInt] = None
+ __properties: ClassVar[List[str]] = ["id", "name", "tsgs", "validation", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotPublishRequest from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotPublishRequest from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "tsgs": obj.get("tsgs"),
+ "validation": obj.get("validation"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_publish_response.py b/scm/config_setup/models/snippet_snapshot_publish_response.py
new file mode 100644
index 00000000..3ea7aec1
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_publish_response.py
@@ -0,0 +1,116 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotPublishResponse(BaseModel):
+ """
+ SnippetSnapshotPublishResponse
+ """ # noqa: E501
+ file_id: Optional[StrictInt] = None
+ id: Optional[StrictStr] = None
+ job_id: Optional[StrictInt] = None
+ tsgs: Optional[List[StrictStr]] = None
+ version: Optional[StrictInt] = None
+ __properties: ClassVar[List[str]] = ["file_id", "id", "job_id", "tsgs", "version"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotPublishResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "file_id",
+ "id",
+ "job_id",
+ "tsgs",
+ "version",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if file_id (nullable) is None
+ # and model_fields_set contains the field
+ if self.file_id is None and "file_id" in self.model_fields_set:
+ _dict['file_id'] = None
+
+ # set to None if version (nullable) is None
+ # and model_fields_set contains the field
+ if self.version is None and "version" in self.model_fields_set:
+ _dict['version'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotPublishResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "file_id": obj.get("file_id"),
+ "id": obj.get("id"),
+ "job_id": obj.get("job_id"),
+ "tsgs": obj.get("tsgs"),
+ "version": obj.get("version")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_subscriber_compare_payload.py b/scm/config_setup/models/snippet_snapshot_subscriber_compare_payload.py
new file mode 100644
index 00000000..bcad79b6
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_subscriber_compare_payload.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotSubscriberComparePayload(BaseModel):
+ """
+ SnippetSnapshotSubscriberComparePayload
+ """ # noqa: E501
+ id: StrictStr
+ tenant_id: StrictStr = Field(description="Publisher Tenant ID")
+ __properties: ClassVar[List[str]] = ["id", "tenant_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotSubscriberComparePayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotSubscriberComparePayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "tenant_id": obj.get("tenant_id")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_subscriber_compare_response.py b/scm/config_setup/models/snippet_snapshot_subscriber_compare_response.py
new file mode 100644
index 00000000..c06f8112
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_subscriber_compare_response.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.snippet_snapshot_subscriber_compare_response_publisher import SnippetSnapshotSubscriberCompareResponsePublisher
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotSubscriberCompareResponse(BaseModel):
+ """
+ SnippetSnapshotSubscriberCompareResponse
+ """ # noqa: E501
+ publisher: Optional[SnippetSnapshotSubscriberCompareResponsePublisher] = None
+ subscriber: Optional[SnippetSnapshotSubscriberCompareResponsePublisher] = None
+ __properties: ClassVar[List[str]] = ["publisher", "subscriber"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotSubscriberCompareResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of publisher
+ if self.publisher:
+ _dict['publisher'] = self.publisher.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of subscriber
+ if self.subscriber:
+ _dict['subscriber'] = self.subscriber.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotSubscriberCompareResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "publisher": SnippetSnapshotSubscriberCompareResponsePublisher.from_dict(obj["publisher"]) if obj.get("publisher") is not None else None,
+ "subscriber": SnippetSnapshotSubscriberCompareResponsePublisher.from_dict(obj["subscriber"]) if obj.get("subscriber") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippet_snapshot_subscriber_compare_response_publisher.py b/scm/config_setup/models/snippet_snapshot_subscriber_compare_response_publisher.py
new file mode 100644
index 00000000..47a65587
--- /dev/null
+++ b/scm/config_setup/models/snippet_snapshot_subscriber_compare_response_publisher.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetSnapshotSubscriberCompareResponsePublisher(BaseModel):
+ """
+ SnippetSnapshotSubscriberCompareResponsePublisher
+ """ # noqa: E501
+ entry: Optional[List[Dict[str, Any]]] = None
+ __properties: ClassVar[List[str]] = ["entry"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotSubscriberCompareResponsePublisher from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetSnapshotSubscriberCompareResponsePublisher from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "entry": obj.get("entry")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippets.py b/scm/config_setup/models/snippets.py
new file mode 100644
index 00000000..18594254
--- /dev/null
+++ b/scm/config_setup/models/snippets.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Snippets(BaseModel):
+ """
+ Snippets
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default=None, description="The description of the snippet")
+ id: StrictStr = Field(description="The UUID of the snippet")
+ labels: Optional[List[StrictStr]] = Field(default=None, description="Labels applied to the snippet")
+ name: StrictStr = Field(description="The name of the snippet")
+ type: Optional[StrictStr] = Field(default=None, description="The snippet type")
+ __properties: ClassVar[List[str]] = ["description", "id", "labels", "name", "type"]
+
+ @field_validator('type')
+ def type_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['predefined', 'custom', 'readonly']):
+ raise ValueError("must be one of enum values ('predefined', 'custom', 'readonly')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Snippets from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ "type",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Snippets from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "id": obj.get("id"),
+ "labels": obj.get("labels"),
+ "name": obj.get("name"),
+ "type": obj.get("type")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/snippets_list_response.py b/scm/config_setup/models/snippets_list_response.py
new file mode 100644
index 00000000..768cbca6
--- /dev/null
+++ b/scm/config_setup/models/snippets_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.config_setup.models.snippets import Snippets
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SnippetsListResponse(BaseModel):
+ """
+ SnippetsListResponse
+ """ # noqa: E501
+ data: List[Snippets]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SnippetsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SnippetsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = Snippets.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [Snippets.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/subscriber_property_payload.py b/scm/config_setup/models/subscriber_property_payload.py
new file mode 100644
index 00000000..21ae41d3
--- /dev/null
+++ b/scm/config_setup/models/subscriber_property_payload.py
@@ -0,0 +1,102 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.property_item import PropertyItem
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SubscriberPropertyPayload(BaseModel):
+ """
+ SubscriberPropertyPayload
+ """ # noqa: E501
+ var_property: Optional[List[PropertyItem]] = Field(default=None, alias="property")
+ snippet_id: StrictStr
+ snippet_name: StrictStr
+ tsg_id: StrictStr
+ __properties: ClassVar[List[str]] = ["property", "snippet_id", "snippet_name", "tsg_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SubscriberPropertyPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in var_property (list)
+ _items = []
+ if self.var_property:
+ for _item_var_property in self.var_property:
+ if _item_var_property:
+ _items.append(_item_var_property.to_dict())
+ _dict['property'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SubscriberPropertyPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "property": [PropertyItem.from_dict(_item) for _item in obj["property"]] if obj.get("property") is not None else None,
+ "snippet_id": obj.get("snippet_id"),
+ "snippet_name": obj.get("snippet_name"),
+ "tsg_id": obj.get("tsg_id")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/tenant_trust_info.py b/scm/config_setup/models/tenant_trust_info.py
new file mode 100644
index 00000000..2d93122f
--- /dev/null
+++ b/scm/config_setup/models/tenant_trust_info.py
@@ -0,0 +1,173 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TenantTrustInfo(BaseModel):
+ """
+ TenantTrustInfo
+ """ # noqa: E501
+ created: Optional[datetime] = None
+ created_by: Optional[StrictStr] = None
+ current_status: Optional[StrictStr] = None
+ donor_cluster: Optional[StrictStr] = None
+ donor_msg_uuid: Optional[StrictStr] = None
+ donor_project: Optional[StrictStr] = None
+ donor_region: Optional[StrictStr] = None
+ donor_tenant_id: Optional[StrictStr] = None
+ donor_tenant_name: Optional[StrictStr] = None
+ donor_trust_info_id: Optional[StrictInt] = None
+ donor_tsg: Optional[StrictStr] = None
+ error_details: Optional[StrictStr] = None
+ last_updated: Optional[datetime] = None
+ psk: Optional[StrictStr] = None
+ recipient_cluster: Optional[StrictStr] = None
+ recipient_msg_uuid: Optional[StrictStr] = None
+ recipient_project: Optional[StrictStr] = None
+ recipient_region: Optional[StrictStr] = None
+ recipient_tenant_id: Optional[StrictStr] = None
+ recipient_tenant_name: Optional[StrictStr] = None
+ recipient_trust_info_id: Optional[StrictInt] = None
+ recipient_tsg: Optional[StrictStr] = None
+ trust_id: Optional[StrictInt] = None
+ updated_by: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["created", "created_by", "current_status", "donor_cluster", "donor_msg_uuid", "donor_project", "donor_region", "donor_tenant_id", "donor_tenant_name", "donor_trust_info_id", "donor_tsg", "error_details", "last_updated", "psk", "recipient_cluster", "recipient_msg_uuid", "recipient_project", "recipient_region", "recipient_tenant_id", "recipient_tenant_name", "recipient_trust_info_id", "recipient_tsg", "trust_id", "updated_by"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TenantTrustInfo from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "created",
+ "created_by",
+ "current_status",
+ "donor_cluster",
+ "donor_msg_uuid",
+ "donor_project",
+ "donor_region",
+ "donor_trust_info_id",
+ "donor_tsg",
+ "error_details",
+ "last_updated",
+ "recipient_cluster",
+ "recipient_msg_uuid",
+ "recipient_project",
+ "recipient_region",
+ "recipient_tenant_id",
+ "recipient_trust_info_id",
+ "recipient_tsg",
+ "updated_by",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TenantTrustInfo from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "created": obj.get("created"),
+ "created_by": obj.get("created_by"),
+ "current_status": obj.get("current_status"),
+ "donor_cluster": obj.get("donor_cluster"),
+ "donor_msg_uuid": obj.get("donor_msg_uuid"),
+ "donor_project": obj.get("donor_project"),
+ "donor_region": obj.get("donor_region"),
+ "donor_tenant_id": obj.get("donor_tenant_id"),
+ "donor_tenant_name": obj.get("donor_tenant_name"),
+ "donor_trust_info_id": obj.get("donor_trust_info_id"),
+ "donor_tsg": obj.get("donor_tsg"),
+ "error_details": obj.get("error_details"),
+ "last_updated": obj.get("last_updated"),
+ "psk": obj.get("psk"),
+ "recipient_cluster": obj.get("recipient_cluster"),
+ "recipient_msg_uuid": obj.get("recipient_msg_uuid"),
+ "recipient_project": obj.get("recipient_project"),
+ "recipient_region": obj.get("recipient_region"),
+ "recipient_tenant_id": obj.get("recipient_tenant_id"),
+ "recipient_tenant_name": obj.get("recipient_tenant_name"),
+ "recipient_trust_info_id": obj.get("recipient_trust_info_id"),
+ "recipient_tsg": obj.get("recipient_tsg"),
+ "trust_id": obj.get("trust_id"),
+ "updated_by": obj.get("updated_by")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/trust_info_with_shared_snippets.py b/scm/config_setup/models/trust_info_with_shared_snippets.py
new file mode 100644
index 00000000..d4cf2862
--- /dev/null
+++ b/scm/config_setup/models/trust_info_with_shared_snippets.py
@@ -0,0 +1,169 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.snippet_share_info import SnippetShareInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrustInfoWithSharedSnippets(BaseModel):
+ """
+ TrustInfoWithSharedSnippets
+ """ # noqa: E501
+ created: Optional[datetime] = None
+ donor_created: Optional[StrictInt] = None
+ donor_snippet_file_id: Optional[StrictInt] = None
+ donor_snippet_version: Optional[StrictInt] = None
+ donor_tsg: Optional[StrictStr] = None
+ error: Optional[StrictStr] = None
+ id: Optional[StrictInt] = None
+ last_updated: Optional[datetime] = None
+ msg_uuid: Optional[StrictStr] = None
+ recipient_paused_update: Optional[StrictInt] = None
+ recipient_snippet_file_id: Optional[StrictInt] = None
+ recipient_snippet_version: Optional[StrictInt] = None
+ recipient_tsg: Optional[StrictStr] = None
+ recipient_validate_before_update: Optional[StrictInt] = None
+ shared_snippets: Optional[List[SnippetShareInfo]] = None
+ snippet_name: Optional[StrictStr] = None
+ snippet_uuid: Optional[StrictStr] = None
+ status: Optional[StrictStr] = None
+ updated_by: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["created", "donor_created", "donor_snippet_file_id", "donor_snippet_version", "donor_tsg", "error", "id", "last_updated", "msg_uuid", "recipient_paused_update", "recipient_snippet_file_id", "recipient_snippet_version", "recipient_tsg", "recipient_validate_before_update", "shared_snippets", "snippet_name", "snippet_uuid", "status", "updated_by"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrustInfoWithSharedSnippets from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "created",
+ "donor_created",
+ "donor_snippet_file_id",
+ "donor_snippet_version",
+ "donor_tsg",
+ "error",
+ "id",
+ "last_updated",
+ "msg_uuid",
+ "recipient_paused_update",
+ "recipient_snippet_file_id",
+ "recipient_snippet_version",
+ "recipient_tsg",
+ "recipient_validate_before_update",
+ "snippet_name",
+ "snippet_uuid",
+ "status",
+ "updated_by",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in shared_snippets (list)
+ _items = []
+ if self.shared_snippets:
+ for _item_shared_snippets in self.shared_snippets:
+ if _item_shared_snippets:
+ _items.append(_item_shared_snippets.to_dict())
+ _dict['shared_snippets'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrustInfoWithSharedSnippets from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "created": obj.get("created"),
+ "donor_created": obj.get("donor_created"),
+ "donor_snippet_file_id": obj.get("donor_snippet_file_id"),
+ "donor_snippet_version": obj.get("donor_snippet_version"),
+ "donor_tsg": obj.get("donor_tsg"),
+ "error": obj.get("error"),
+ "id": obj.get("id"),
+ "last_updated": obj.get("last_updated"),
+ "msg_uuid": obj.get("msg_uuid"),
+ "recipient_paused_update": obj.get("recipient_paused_update"),
+ "recipient_snippet_file_id": obj.get("recipient_snippet_file_id"),
+ "recipient_snippet_version": obj.get("recipient_snippet_version"),
+ "recipient_tsg": obj.get("recipient_tsg"),
+ "recipient_validate_before_update": obj.get("recipient_validate_before_update"),
+ "shared_snippets": [SnippetShareInfo.from_dict(_item) for _item in obj["shared_snippets"]] if obj.get("shared_snippets") is not None else None,
+ "snippet_name": obj.get("snippet_name"),
+ "snippet_uuid": obj.get("snippet_uuid"),
+ "status": obj.get("status"),
+ "updated_by": obj.get("updated_by")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/trusted_tenant_overview.py b/scm/config_setup/models/trusted_tenant_overview.py
new file mode 100644
index 00000000..1286dc29
--- /dev/null
+++ b/scm/config_setup/models/trusted_tenant_overview.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.config_setup.models.trusted_tenant_overview_publisher import TrustedTenantOverviewPublisher
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrustedTenantOverview(BaseModel):
+ """
+ TrustedTenantOverview
+ """ # noqa: E501
+ publisher: Optional[TrustedTenantOverviewPublisher] = None
+ subscriber: Optional[TrustedTenantOverviewPublisher] = None
+ __properties: ClassVar[List[str]] = ["publisher", "subscriber"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrustedTenantOverview from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of publisher
+ if self.publisher:
+ _dict['publisher'] = self.publisher.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of subscriber
+ if self.subscriber:
+ _dict['subscriber'] = self.subscriber.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrustedTenantOverview from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "publisher": TrustedTenantOverviewPublisher.from_dict(obj["publisher"]) if obj.get("publisher") is not None else None,
+ "subscriber": TrustedTenantOverviewPublisher.from_dict(obj["subscriber"]) if obj.get("subscriber") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/trusted_tenant_overview_publisher.py b/scm/config_setup/models/trusted_tenant_overview_publisher.py
new file mode 100644
index 00000000..aaa5ca75
--- /dev/null
+++ b/scm/config_setup/models/trusted_tenant_overview_publisher.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrustedTenantOverviewPublisher(BaseModel):
+ """
+ TrustedTenantOverviewPublisher
+ """ # noqa: E501
+ pending: Optional[StrictInt] = None
+ total: Optional[StrictInt] = None
+ __properties: ClassVar[List[str]] = ["pending", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrustedTenantOverviewPublisher from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "pending",
+ "total",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrustedTenantOverviewPublisher from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "pending": obj.get("pending"),
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/trusts.py b/scm/config_setup/models/trusts.py
new file mode 100644
index 00000000..7904e862
--- /dev/null
+++ b/scm/config_setup/models/trusts.py
@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Trusts(BaseModel):
+ """
+ Trusts
+ """ # noqa: E501
+ donor_tenant_name: Optional[StrictStr] = None
+ psk: Optional[StrictStr] = None
+ recipient_tenant_name: Optional[StrictStr] = None
+ trust_id: Optional[StrictInt] = None
+ tsg: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["donor_tenant_name", "psk", "recipient_tenant_name", "trust_id", "tsg"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Trusts from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if trust_id (nullable) is None
+ # and model_fields_set contains the field
+ if self.trust_id is None and "trust_id" in self.model_fields_set:
+ _dict['trust_id'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Trusts from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "donor_tenant_name": obj.get("donor_tenant_name"),
+ "psk": obj.get("psk"),
+ "recipient_tenant_name": obj.get("recipient_tenant_name"),
+ "trust_id": obj.get("trust_id"),
+ "tsg": obj.get("tsg")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/trusts_validation_payload.py b/scm/config_setup/models/trusts_validation_payload.py
new file mode 100644
index 00000000..004885cc
--- /dev/null
+++ b/scm/config_setup/models/trusts_validation_payload.py
@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrustsValidationPayload(BaseModel):
+ """
+ TrustsValidationPayload
+ """ # noqa: E501
+ donor_tenant_name: StrictStr
+ psk: StrictStr
+ recipient_tenant_name: StrictStr
+ trust_id: Optional[StrictInt]
+ tsg: StrictStr
+ __properties: ClassVar[List[str]] = ["donor_tenant_name", "psk", "recipient_tenant_name", "trust_id", "tsg"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrustsValidationPayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if trust_id (nullable) is None
+ # and model_fields_set contains the field
+ if self.trust_id is None and "trust_id" in self.model_fields_set:
+ _dict['trust_id'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrustsValidationPayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "donor_tenant_name": obj.get("donor_tenant_name"),
+ "psk": obj.get("psk"),
+ "recipient_tenant_name": obj.get("recipient_tenant_name"),
+ "trust_id": obj.get("trust_id"),
+ "tsg": obj.get("tsg")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/used_folders.py b/scm/config_setup/models/used_folders.py
new file mode 100644
index 00000000..9fc83335
--- /dev/null
+++ b/scm/config_setup/models/used_folders.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UsedFolders(BaseModel):
+ """
+ UsedFolders
+ """ # noqa: E501
+ id: Optional[StrictStr] = None
+ name: StrictStr
+ __properties: ClassVar[List[str]] = ["id", "name"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UsedFolders from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UsedFolders from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "name": obj.get("name")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/variables.py b/scm/config_setup/models/variables.py
new file mode 100644
index 00000000..4ffa68d8
--- /dev/null
+++ b/scm/config_setup/models/variables.py
@@ -0,0 +1,151 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Variables(BaseModel):
+ """
+ Variables
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default=None, description="The description of the variable")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="UUID of the variable")
+ name: Annotated[str, Field(strict=True, max_length=63)] = Field(description="The name of the variable")
+ overridden: Optional[StrictBool] = Field(default=None, description="Is the variable overridden?")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ type: StrictStr = Field(description="The variable type")
+ value: Optional[Any] = Field(description="The value of the variable")
+ __properties: ClassVar[List[str]] = ["description", "device", "folder", "id", "name", "overridden", "snippet", "type", "value"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d_\-. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d_\-. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d_\-. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d_\-. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d_\-. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d_\-. ]+$/")
+ return value
+
+ @field_validator('type')
+ def type_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['percent', 'count', 'ip-netmask', 'zone', 'ip-range', 'ip-wildcard', 'device-priority', 'device-id', 'egress-max', 'as-number', 'fqdn', 'port', 'link-tag', 'group-id', 'rate', 'router-id', 'qos-profile', 'timer']):
+ raise ValueError("must be one of enum values ('percent', 'count', 'ip-netmask', 'zone', 'ip-range', 'ip-wildcard', 'device-priority', 'device-id', 'egress-max', 'as-number', 'fqdn', 'port', 'link-tag', 'group-id', 'rate', 'router-id', 'qos-profile', 'timer')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Variables from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ "overridden",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if value (nullable) is None
+ # and model_fields_set contains the field
+ if self.value is None and "value" in self.model_fields_set:
+ _dict['value'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Variables from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "overridden": obj.get("overridden"),
+ "snippet": obj.get("snippet"),
+ "type": obj.get("type"),
+ "value": obj.get("value")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/models/variables_list_response.py b/scm/config_setup/models/variables_list_response.py
new file mode 100644
index 00000000..a95b0b71
--- /dev/null
+++ b/scm/config_setup/models/variables_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.config_setup.models.variables import Variables
+from typing import Optional, Set
+from typing_extensions import Self
+
+class VariablesListResponse(BaseModel):
+ """
+ VariablesListResponse
+ """ # noqa: E501
+ data: List[Variables]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of VariablesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of VariablesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = Variables.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [Variables.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/config_setup/rest.py b/scm/config_setup/rest.py
new file mode 100644
index 00000000..506126a8
--- /dev/null
+++ b/scm/config_setup/rest.py
@@ -0,0 +1,258 @@
+# coding: utf-8
+
+"""
+ Configuration Setup
+
+ These APIs are used to define how Strata Cloud Manager configurations are implemented.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import io
+import json
+import re
+import ssl
+
+import urllib3
+
+from scm.config_setup.exceptions import ApiException, ApiValueError
+
+SUPPORTED_SOCKS_PROXIES = {"socks5", "socks5h", "socks4", "socks4a"}
+RESTResponseType = urllib3.HTTPResponse
+
+
+def is_socks_proxy_url(url):
+ if url is None:
+ return False
+ split_section = url.split("://")
+ if len(split_section) < 2:
+ return False
+ else:
+ return split_section[0].lower() in SUPPORTED_SOCKS_PROXIES
+
+
+class RESTResponse(io.IOBase):
+
+ def __init__(self, resp) -> None:
+ self.response = resp
+ self.status = resp.status
+ self.reason = resp.reason
+ self.data = None
+
+ def read(self):
+ if self.data is None:
+ self.data = self.response.data
+ return self.data
+
+ def getheaders(self):
+ """Returns a dictionary of the response headers."""
+ return self.response.headers
+
+ def getheader(self, name, default=None):
+ """Returns a given response header."""
+ return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+ def __init__(self, configuration) -> None:
+ # urllib3.PoolManager will pass all kw parameters to connectionpool
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501
+ # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501
+
+ # cert_reqs
+ if configuration.verify_ssl:
+ cert_reqs = ssl.CERT_REQUIRED
+ else:
+ cert_reqs = ssl.CERT_NONE
+
+ pool_args = {
+ "cert_reqs": cert_reqs,
+ "ca_certs": configuration.ssl_ca_cert,
+ "cert_file": configuration.cert_file,
+ "key_file": configuration.key_file,
+ }
+ if configuration.assert_hostname is not None:
+ pool_args['assert_hostname'] = (
+ configuration.assert_hostname
+ )
+
+ if configuration.retries is not None:
+ pool_args['retries'] = configuration.retries
+
+ if configuration.tls_server_name:
+ pool_args['server_hostname'] = configuration.tls_server_name
+
+
+ if configuration.socket_options is not None:
+ pool_args['socket_options'] = configuration.socket_options
+
+ if configuration.connection_pool_maxsize is not None:
+ pool_args['maxsize'] = configuration.connection_pool_maxsize
+
+ # https pool manager
+ self.pool_manager: urllib3.PoolManager
+
+ if configuration.proxy:
+ if is_socks_proxy_url(configuration.proxy):
+ from urllib3.contrib.socks import SOCKSProxyManager
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["headers"] = configuration.proxy_headers
+ self.pool_manager = SOCKSProxyManager(**pool_args)
+ else:
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["proxy_headers"] = configuration.proxy_headers
+ self.pool_manager = urllib3.ProxyManager(**pool_args)
+ else:
+ self.pool_manager = urllib3.PoolManager(**pool_args)
+
+ def request(
+ self,
+ method,
+ url,
+ headers=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ):
+ """Perform requests.
+
+ :param method: http request method
+ :param url: http request url
+ :param headers: http request headers
+ :param body: request json body, for `application/json`
+ :param post_params: request post parameters,
+ `application/x-www-form-urlencoded`
+ and `multipart/form-data`
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ """
+ method = method.upper()
+ assert method in [
+ 'GET',
+ 'HEAD',
+ 'DELETE',
+ 'POST',
+ 'PUT',
+ 'PATCH',
+ 'OPTIONS'
+ ]
+
+ if post_params and body:
+ raise ApiValueError(
+ "body parameter cannot be used with post_params parameter."
+ )
+
+ post_params = post_params or {}
+ headers = headers or {}
+
+ timeout = None
+ if _request_timeout:
+ if isinstance(_request_timeout, (int, float)):
+ timeout = urllib3.Timeout(total=_request_timeout)
+ elif (
+ isinstance(_request_timeout, tuple)
+ and len(_request_timeout) == 2
+ ):
+ timeout = urllib3.Timeout(
+ connect=_request_timeout[0],
+ read=_request_timeout[1]
+ )
+
+ try:
+ # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+ if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+
+ # no content type provided or payload is json
+ content_type = headers.get('Content-Type')
+ if (
+ not content_type
+ or re.search('json', content_type, re.IGNORECASE)
+ ):
+ request_body = None
+ if body is not None:
+ request_body = json.dumps(body)
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'application/x-www-form-urlencoded':
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=False,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'multipart/form-data':
+ # must del headers['Content-Type'], or the correct
+ # Content-Type which generated by urllib3 will be
+ # overwritten.
+ del headers['Content-Type']
+ # Ensures that dict objects are serialized
+ post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a,b) for a, b in post_params]
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=True,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ # Pass a `string` parameter directly in the body to support
+ # other content types than JSON when `body` argument is
+ # provided in serialized form.
+ elif isinstance(body, str) or isinstance(body, bytes):
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif headers['Content-Type'].startswith('text/') and isinstance(body, bool):
+ request_body = "true" if body else "false"
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ preload_content=False,
+ timeout=timeout,
+ headers=headers)
+ else:
+ # Cannot generate the request from given parameters
+ msg = """Cannot prepare a request message for provided
+ arguments. Please check that your arguments match
+ declared content type."""
+ raise ApiException(status=0, reason=msg)
+ # For `GET`, `HEAD`
+ else:
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields={},
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ except urllib3.exceptions.SSLError as e:
+ msg = "\n".join([type(e).__name__, str(e)])
+ raise ApiException(status=0, reason=msg)
+
+ return RESTResponse(r)
diff --git a/scm/config_setup/tests/__init__.py b/scm/config_setup/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/scm/config_setup/tests/api_folders_test.py b/scm/config_setup/tests/api_folders_test.py
new file mode 100644
index 00000000..b1e9f1b2
--- /dev/null
+++ b/scm/config_setup/tests/api_folders_test.py
@@ -0,0 +1,36 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def folders_api(client):
+ return client.config_setup.FoldersApi(client.config_setup.api_client)
+
+
+def test_list_folders(folders_api):
+ """Test listing Folders."""
+ response = folders_api.list_folders(limit=200, offset=0)
+ assert response is not None
+ logger.info(f"Listed Folders successfully")
+
+
+def test_fetch_folders(folders_api):
+ """Test fetching a non-existent Folder returns None."""
+ result = folders_api.fetch_folders(
+ name="non-existent-folder-xyz-12345"
+ )
+ assert result is None, "Should return None for non-existent folder"
+ logger.info("fetch_folders correctly returned None for non-existent object")
diff --git a/scm/config_setup/tests/api_labels_test.py b/scm/config_setup/tests/api_labels_test.py
new file mode 100644
index 00000000..b4a130be
--- /dev/null
+++ b/scm/config_setup/tests/api_labels_test.py
@@ -0,0 +1,188 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.config_setup.models.labels import Labels
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+# Labels do not use folder - they are global resources
+# -----------------------------------------------------------------------------
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def labels_api(client):
+ """
+ Fixture to return the Labels API instance.
+ """
+ return client.config_setup.LabelsApi(client.config_setup.api_client)
+
+@pytest.fixture
+def clean_label(labels_api):
+ """
+ Fixture to create a temporary Label for testing and automatically delete it after.
+ """
+ # 1. SETUP: Create Label
+ random_id = uuid.uuid4().hex[:6]
+ label_name = f"test-label-{random_id}"
+
+ payload = Labels(
+ id="",
+ name=label_name,
+ description="Created via Automated Pytest Fixture"
+ )
+
+ logger.info(f"\n[SETUP] Creating Label: {label_name}")
+ created_obj = labels_api.create_label(labels=payload)
+ assert created_obj.id is not None
+
+ # Pass control to the test function
+ yield created_obj
+
+ # 2. TEARDOWN: Delete Label
+ logger.info(f"\n[TEARDOWN] Deleting Label ID: {created_obj.id}")
+ try:
+ labels_api.delete_label_by_id(id=created_obj.id)
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_label(labels_api):
+ """
+ Test manual creation and deletion of a label.
+ Equivalent to Go: Test_config_setup_LabelsAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ label_name = f"test-label-create-{random_suffix}"
+
+ payload = Labels(
+ id="",
+ name=label_name,
+ description="Test label for create API testing"
+ )
+
+ # Create
+ created_obj = labels_api.create_label(labels=payload)
+
+ # Verify
+ assert created_obj.name == label_name
+ assert created_obj.id is not None
+ assert created_obj.description == "Test label for create API testing"
+
+ logger.info(f"Successfully created label: {label_name} with ID: {created_obj.id}")
+
+ # Cleanup
+ labels_api.delete_label_by_id(id=created_obj.id)
+ logger.info(f"Successfully cleaned up label: {created_obj.id}")
+
+
+def test_get_label_by_id(labels_api, clean_label):
+ """
+ Test retrieving a label by ID.
+ Equivalent to Go: Test_config_setup_LabelsAPIService_GetByID
+ """
+ # Retrieve
+ fetched_obj = labels_api.get_label_by_id(id=clean_label.id)
+
+ # Verify
+ assert fetched_obj.id == clean_label.id
+ assert fetched_obj.name == clean_label.name
+
+
+def test_update_label(labels_api, clean_label):
+ """
+ Test updating an existing label.
+ Equivalent to Go: Test_config_setup_LabelsAPIService_Update
+
+ NOTE: Skipped because API returns array in update response but model expects object.
+ This is a known issue in both Go and Python SDKs.
+ """
+ pytest.skip("API returns array in update response but model expects object - model deserialization error")
+
+
+def test_list_labels(labels_api, clean_label):
+ """
+ Test listing labels.
+ Equivalent to Go: Test_config_setup_LabelsAPIService_List
+
+ NOTE: Labels do not use folder filter - they are global resources.
+ """
+ # List labels (no folder filter for labels)
+ response = labels_api.list_labels(limit=500)
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ # Verify at least one label exists (our created one should be there)
+ logger.info(f"\n[SUCCESS] List returned {len(response.data)} items.")
+
+
+
+
+def test_fetch_labels(labels_api, clean_label):
+ """
+ Test fetching a single label by name using the fetch convenience method.
+ Equivalent to Go: Test_config_setup_LabelsAPIService_FetchLabels
+ """
+ # Fetch by exact name (no folder for labels)
+ fetched_obj = labels_api.fetch_labels(
+ name=clean_label.name
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found label '{clean_label.name}'"
+ assert fetched_obj.id == clean_label.id
+ assert fetched_obj.name == clean_label.name
+ logger.info(f"\n[SUCCESS] fetch_labels found object: {fetched_obj.name}")
+
+ # Test fetching non-existent label (should return None)
+ not_found = labels_api.fetch_labels(
+ name="non-existent-labels-xyz-12345"
+ )
+ assert not_found is None, "Should return None for non-existent label"
+ logger.info(f"\n[SUCCESS] fetch_labels correctly returned None for non-existent label")
+
+
+def test_delete_label_by_id(labels_api):
+ """
+ Test deletion specifically.
+ Equivalent to Go: Test_config_setup_LabelsAPIService_DeleteByID
+ """
+ # Setup
+ random_suffix = uuid.uuid4().hex[:6]
+ label_name = f"test-label-delete-{random_suffix}"
+
+ payload = Labels(
+ id="",
+ name=label_name,
+ description="Test label for delete API testing"
+ )
+ created_obj = labels_api.create_label(labels=payload)
+
+ # Perform Delete
+ labels_api.delete_label_by_id(id=created_obj.id)
+
+ # Verify Deletion (Expect error on Get)
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ labels_api.get_label_by_id(id=created_obj.id)
+ pytest.fail("Label should have been deleted but was found.")
+ except (ObjectNotPresentError, Exception) as e:
+ logger.info(f"Correctly raised error for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/config_setup/tests/api_shared_snippets_test.py b/scm/config_setup/tests/api_shared_snippets_test.py
new file mode 100644
index 00000000..e5b450db
--- /dev/null
+++ b/scm/config_setup/tests/api_shared_snippets_test.py
@@ -0,0 +1,27 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def shared_snippets_api(client):
+ return client.config_setup.SharedSnippetsApi(client.config_setup.api_client)
+
+
+def test_list_shared_snippets(shared_snippets_api):
+ """Test listing Shared Snippets (read-only resource)."""
+ response = shared_snippets_api.list_shared_snippets()
+ assert response is not None
+ logger.info(f"Listed Shared Snippets successfully")
diff --git a/scm/config_setup/tests/api_snippet_categories_test.py b/scm/config_setup/tests/api_snippet_categories_test.py
new file mode 100644
index 00000000..2cf7aae0
--- /dev/null
+++ b/scm/config_setup/tests/api_snippet_categories_test.py
@@ -0,0 +1,45 @@
+
+import logging
+import pytest
+from scm import Scm
+from scm.test_helpers import perform
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def snippet_categories_api(client):
+ return client.config_setup.SnippetCategoriesApi(client.config_setup.api_client)
+
+
+def test_list_snippet_categories(snippet_categories_api):
+ """Test listing Snippet Categories."""
+ pytest.skip("API returns bare JSON array but SDK expects paginated response")
+
+
+def test_get_snippet_category_by_id(snippet_categories_api):
+ """
+ Test retrieving a snippet category by ID.
+ Equivalent to Go: Test_config_setup_SnippetCategoriesAPIService_GetByID
+ """
+ # NOTE: GetByID requires a valid ID, but the only way to discover one
+ # is via List or Fetch — both fail because the API returns a bare JSON
+ # array that the SDK can't deserialize. Go works because its Fetch
+ # handles bare arrays differently. Skip until the model mismatch is fixed.
+ pytest.skip("Cannot discover IDs — List/Fetch fail due to bare JSON array response")
+
+
+def test_fetch_snippet_categories(snippet_categories_api):
+ """Test fetching a non-existent Snippet Category returns None."""
+ # NOTE: Fetch internally calls List with name= filter, but the API returns
+ # a bare JSON array causing BadRequestError. Skip until model mismatch is fixed.
+ pytest.skip("Fetch relies on List which fails due to bare JSON array response")
diff --git a/scm/config_setup/tests/api_snippets_test.py b/scm/config_setup/tests/api_snippets_test.py
new file mode 100644
index 00000000..15193f5e
--- /dev/null
+++ b/scm/config_setup/tests/api_snippets_test.py
@@ -0,0 +1,224 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.config_setup.models.snippets import Snippets
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def snippets_api(client):
+ """
+ Fixture to return the Snippets API instance.
+ """
+ return client.config_setup.SnippetsApi(client.config_setup.api_client)
+
+@pytest.fixture
+def clean_snippet(snippets_api):
+ """
+ Fixture to create a temporary Snippet for testing and automatically delete it after.
+ """
+ # 1. SETUP: Create Snippet
+ random_id = uuid.uuid4().hex[:6]
+ snippet_name = f"test-snippet-{random_id}"
+
+ payload = Snippets(
+ id="",
+ name=snippet_name,
+ description="Created via Automated Pytest Fixture",
+ type="custom" # Required for snippet to be updateable
+ )
+
+ logger.info(f"\n[SETUP] Creating Snippet: {snippet_name}")
+ created_obj = perform(
+ snippets_api.create_snippet_with_http_info,
+ response_type=Snippets,
+ snippets=payload
+ )
+ assert created_obj.id is not None
+
+ # Pass control to the test function
+ yield created_obj
+
+ # 2. TEARDOWN: Delete Snippet
+ logger.info(f"\n[TEARDOWN] Deleting Snippet ID: {created_obj.id}")
+ try:
+ perform(
+ snippets_api.delete_snippet_by_id,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_snippet(snippets_api):
+ """
+ Test manual creation and deletion of a snippet object.
+ Equivalent to Go: Test_config_setup_SnippetsAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ snippet_name = f"test-snippet-create-{random_suffix}"
+
+ payload = Snippets(
+ id="",
+ name=snippet_name,
+ description="Test snippet for create API testing"
+ )
+
+ # Create using perform helper
+ created_obj = perform(
+ snippets_api.create_snippet_with_http_info,
+ response_type=Snippets,
+ snippets=payload
+ )
+
+ # Verify
+ assert created_obj.name == snippet_name
+ assert created_obj.id is not None
+ assert created_obj.description == "Test snippet for create API testing"
+
+ # Cleanup
+ perform(
+ snippets_api.delete_snippet_by_id,
+ id=created_obj.id
+ )
+
+
+def test_get_snippet_by_id(snippets_api, clean_snippet):
+ """
+ Test retrieving a snippet by ID.
+ Equivalent to Go: Test_config_setup_SnippetsAPIService_GetByID
+ """
+ # Retrieve using perform helper
+ fetched_obj = perform(
+ snippets_api.get_snippet_by_id,
+ response_type=Snippets,
+ id=clean_snippet.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_snippet.id
+ assert fetched_obj.name == clean_snippet.name
+ assert fetched_obj.description == clean_snippet.description
+
+
+def test_update_snippet(snippets_api, clean_snippet):
+ """
+ Test updating an existing snippet.
+ Equivalent to Go: Test_config_setup_SnippetsAPIService_Update
+
+ NOTE: This test is skipped because the API does not support updating snippets.
+ Both Go and Python SDK tests fail with "FAILED to update merged-config" error.
+ """
+ pytest.skip("Snippet updates not supported by the API - both Go and Python SDKs fail")
+
+
+def test_list_snippets(snippets_api, clean_snippet):
+ """
+ Test listing snippets.
+ Equivalent to Go: Test_config_setup_SnippetsAPIService_List
+ """
+ # List using perform helper
+ response = perform(
+ snippets_api.list_snippets,
+ limit=10000
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ # Verify our created object is in the list
+ found = False
+ for item in response.data:
+ if item.name == clean_snippet.name:
+ found = True
+ break
+
+ assert found is True
+ logger.info(f"\n[SUCCESS] List returned {len(response.data)} items.")
+
+
+
+
+def test_fetch_snippets(snippets_api, clean_snippet):
+ """
+ Test fetching a single snippets by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = snippets_api.fetch_snippets(
+ name=clean_snippet.name,
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found snippets '{clean_snippet.name}'"
+ assert fetched_obj.id == clean_snippet.id
+ assert fetched_obj.name == clean_snippet.name
+ # Folder attribute not applicable for this resource
+ logger.info(f"\n[SUCCESS] fetch_snippets found object: {fetched_obj.name}")
+
+ # Test fetching non-existent snippets (should return None)
+ not_found = snippets_api.fetch_snippets(
+ name="non-existent-snippets-xyz-12345",
+ )
+ assert not_found is None, "Should return None for non-existent snippets"
+ logger.info(f"\n[SUCCESS] fetch_snippets correctly returned None for non-existent snippets")
+
+
+def test_delete_snippet_by_id(snippets_api):
+ """
+ Test deletion specifically.
+ Equivalent to Go: Test_config_setup_SnippetsAPIService_DeleteByID
+ """
+ # Setup
+ random_suffix = uuid.uuid4().hex[:6]
+ snippet_name = f"test-snippet-delete-{random_suffix}"
+
+ payload = Snippets(
+ id="",
+ name=snippet_name,
+ description="Test snippet for delete API testing"
+ )
+ created_obj = perform(
+ snippets_api.create_snippet_with_http_info,
+ response_type=Snippets,
+ snippets=payload
+ )
+
+ # Perform Delete using helper
+ perform(
+ snippets_api.delete_snippet_by_id,
+ id=created_obj.id
+ )
+
+ # Verify Deletion (Expect ObjectNotPresentError on Get)
+ from scm.exceptions import ObjectNotPresentError
+ # Decorator already converts NotFoundException to ObjectNotPresentError
+
+ try:
+ snippets_api.get_snippet_by_id(id=created_obj.id)
+ pytest.fail("Snippet should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/config_setup/tests/api_subscribed_tenants_test.py b/scm/config_setup/tests/api_subscribed_tenants_test.py
new file mode 100644
index 00000000..1f3ae9f0
--- /dev/null
+++ b/scm/config_setup/tests/api_subscribed_tenants_test.py
@@ -0,0 +1,41 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def snippet_categories_api(client):
+ return client.config_setup.SnippetCategoriesApi(client.config_setup.api_client)
+
+
+@pytest.fixture(scope="module")
+def subscribed_tenants_api(client):
+ return client.config_setup.SubscribedTenantsApi(client.config_setup.api_client)
+
+
+def test_list_subscribed_tenants(snippet_categories_api, subscribed_tenants_api):
+ """Test listing Subscribed Tenants for a known snippet."""
+ # First, find a snippet ID via snippet categories
+ snippet = snippet_categories_api.fetch_snippet_categories(name="app-tagging")
+ if snippet is None:
+ pytest.skip("Could not find 'app-tagging' snippet category - skipping subscribed tenants test")
+
+ snippet_id = snippet.id
+ logger.info(f"Found snippet 'app-tagging' with ID: {snippet_id}")
+
+ # List subscribed tenants for the snippet
+ response = subscribed_tenants_api.list_subscribed_tenants_by_id(id=snippet_id)
+ assert response is not None
+ logger.info(f"Listed Subscribed Tenants for snippet ID {snippet_id} successfully")
diff --git a/scm/config_setup/tests/api_trust_information_test.py b/scm/config_setup/tests/api_trust_information_test.py
new file mode 100644
index 00000000..d768815e
--- /dev/null
+++ b/scm/config_setup/tests/api_trust_information_test.py
@@ -0,0 +1,27 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def trust_information_api(client):
+ return client.config_setup.TrustInformationApi(client.config_setup.api_client)
+
+
+def test_list_trusted_tenants_with_snippets(trust_information_api):
+ """Test listing Trusted Tenants with Snippets."""
+ response = trust_information_api.list_trusted_tenants_with_snippets(type="subscriber")
+ assert response is not None
+ logger.info(f"Listed Trusted Tenants with Snippets successfully")
diff --git a/scm/config_setup/tests/api_variables_test.py b/scm/config_setup/tests/api_variables_test.py
new file mode 100644
index 00000000..c8c3d684
--- /dev/null
+++ b/scm/config_setup/tests/api_variables_test.py
@@ -0,0 +1,255 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.config_setup.models.variables import Variables
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def variables_api(client):
+ """
+ Fixture to return the Variables API instance.
+ """
+ return client.config_setup.VariablesApi(client.config_setup.api_client)
+
+@pytest.fixture
+def clean_variable(variables_api):
+ """
+ Fixture to create a temporary Variable for testing and automatically delete it after.
+ """
+ # 1. SETUP: Create Variable
+ random_id = uuid.uuid4().hex[:6]
+ variable_name = f"$test-var-{random_id}"
+
+ payload = Variables(
+ id="",
+ name=variable_name,
+ folder=TARGET_FOLDER,
+ type="ip-netmask",
+ value="10.0.0.1/32",
+ description="Created via Automated Pytest Fixture"
+ )
+
+ logger.info(f"\n[SETUP] Creating Variable: {variable_name}")
+ created_obj = perform(
+ variables_api.create_variable_with_http_info,
+ response_type=Variables,
+ variables=payload
+ )
+ assert created_obj.id is not None
+
+ # Pass control to the test function
+ yield created_obj
+
+ # 2. TEARDOWN: Delete Variable
+ logger.info(f"\n[TEARDOWN] Deleting Variable ID: {created_obj.id}")
+ try:
+ perform(
+ variables_api.delete_variable_by_id,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_variable(variables_api):
+ """
+ Test manual creation and deletion of a variable object.
+ Equivalent to Go: Test_config_setup_VariablesAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ variable_name = f"$test-var-create-{random_suffix}"
+
+ payload = Variables(
+ id="",
+ name=variable_name,
+ folder=TARGET_FOLDER,
+ type="fqdn",
+ value="example.com",
+ description="Test variable for create API testing"
+ )
+
+ # Create using perform helper
+ created_obj = perform(
+ variables_api.create_variable_with_http_info,
+ response_type=Variables,
+ variables=payload
+ )
+
+ # Verify
+ assert created_obj.name == variable_name
+ assert created_obj.id is not None
+ assert created_obj.folder == TARGET_FOLDER
+ assert created_obj.type == "fqdn"
+ assert created_obj.value == "example.com"
+ assert created_obj.description == "Test variable for create API testing"
+
+ # Cleanup
+ perform(
+ variables_api.delete_variable_by_id,
+ id=created_obj.id
+ )
+
+
+def test_get_variable_by_id(variables_api, clean_variable):
+ """
+ Test retrieving a variable by ID.
+ Equivalent to Go: Test_config_setup_VariablesAPIService_GetByID
+ """
+ # Retrieve using perform helper
+ fetched_obj = perform(
+ variables_api.get_variable_by_id,
+ response_type=Variables,
+ id=clean_variable.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_variable.id
+ assert fetched_obj.name == clean_variable.name
+ assert fetched_obj.folder == clean_variable.folder
+ assert fetched_obj.type == clean_variable.type
+ assert fetched_obj.value == clean_variable.value
+
+
+def test_update_variable(variables_api, clean_variable):
+ """
+ Test updating an existing variable.
+ Equivalent to Go: Test_config_setup_VariablesAPIService_Update
+ """
+ # Prepare Update Payload
+ update_payload = clean_variable
+ update_payload.description = "Updated test variable description"
+ update_payload.value = "192.168.1.1/32"
+
+ # Perform Update using helper
+ updated_obj = perform(
+ variables_api.update_variable_by_id,
+ response_type=Variables,
+ id=clean_variable.id,
+ variables=update_payload
+ )
+
+ # Verify
+ assert updated_obj.id == clean_variable.id
+ assert updated_obj.name == clean_variable.name
+ assert updated_obj.description == "Updated test variable description"
+ assert updated_obj.value == "192.168.1.1/32"
+ assert updated_obj.type == clean_variable.type
+
+
+def test_list_variables(variables_api, clean_variable):
+ """
+ Test listing variables with folder filter.
+ Equivalent to Go: Test_config_setup_VariablesAPIService_List
+ """
+ # List with folder filter using perform helper
+ response = perform(
+ variables_api.list_variables,
+ folder=TARGET_FOLDER,
+ limit=10000
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ # Verify our created object is in the list
+ found = False
+ for item in response.data:
+ if item.name == clean_variable.name:
+ found = True
+ break
+
+ assert found is True
+ logger.info(f"\n[SUCCESS] List returned {len(response.data)} items.")
+
+
+
+
+def test_fetch_variables(variables_api, clean_variable):
+ """
+ Test fetching a single variables by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = variables_api.fetch_variables(
+ name=clean_variable.name,
+ folder=clean_variable.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found variables '{clean_variable.name}'"
+ assert fetched_obj.id == clean_variable.id
+ assert fetched_obj.name == clean_variable.name
+ assert fetched_obj.folder == clean_variable.folder
+ logger.info(f"\n[SUCCESS] fetch_variables found object: {fetched_obj.name}")
+
+ # Test fetching non-existent variables (should return None)
+ not_found = variables_api.fetch_variables(
+ name="non-existent-variables-xyz-12345",
+ folder=clean_variable.folder
+ )
+ assert not_found is None, "Should return None for non-existent variables"
+ logger.info(f"\n[SUCCESS] fetch_variables correctly returned None for non-existent variables")
+
+
+def test_delete_variable_by_id(variables_api):
+ """
+ Test deletion specifically.
+ Equivalent to Go: Test_config_setup_VariablesAPIService_DeleteByID
+ """
+ # Setup
+ random_suffix = uuid.uuid4().hex[:6]
+ variable_name = f"$test-var-delete-{random_suffix}"
+
+ payload = Variables(
+ id="",
+ name=variable_name,
+ folder=TARGET_FOLDER,
+ type="port",
+ value="8080",
+ description="Test variable for delete API testing"
+ )
+ created_obj = perform(
+ variables_api.create_variable_with_http_info,
+ response_type=Variables,
+ variables=payload
+ )
+
+ # Perform Delete using helper
+ perform(
+ variables_api.delete_variable_by_id,
+ id=created_obj.id
+ )
+
+ # Verify Deletion (Expect ObjectNotPresentError on Get)
+ from scm.exceptions import ObjectNotPresentError
+ # Decorator already converts NotFoundException to ObjectNotPresentError
+
+ try:
+ variables_api.get_variable_by_id(id=created_obj.id)
+ pytest.fail("Variable should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/decorators.py b/scm/decorators.py
new file mode 100644
index 00000000..87e9ac03
--- /dev/null
+++ b/scm/decorators.py
@@ -0,0 +1,110 @@
+"""
+Decorators for automatic exception handling in SCM SDK.
+
+This module provides decorators that automatically convert OpenAPI-generated
+exceptions into custom SCM exceptions with better error messages and structure.
+"""
+
+from functools import wraps
+from typing import Callable, Any
+from scm.error_parser import ErrorHandler
+
+
+def _log_error_headers(exception):
+ """
+ Log response headers on API errors for debugging.
+ Prints X-Request-ID and X-Trace-ID headers when available.
+ """
+ print("=== API RESPONSE HEADERS ===")
+
+ # Get status code
+ status = getattr(exception, 'status', None)
+ if status:
+ print(f"Status Code: {status}")
+
+ # Get headers from exception
+ headers = getattr(exception, 'headers', None)
+ request_id = None
+ trace_id = None
+ flow_error = None
+
+ if headers:
+ # Handle HTTPHeaderDict (dict-like) from urllib3
+ if hasattr(headers, 'get'):
+ request_id = headers.get('X-Request-ID') or headers.get('x-request-id')
+ trace_id = headers.get('X-Trace-ID') or headers.get('x-trace-id')
+ flow_error = headers.get('X-Request-Flow-Error') or headers.get('x-request-flow-error')
+ # Handle list of tuples from getheaders()
+ elif isinstance(headers, list):
+ for name, value in headers:
+ name_lower = name.lower()
+ if name_lower == 'x-request-id':
+ request_id = value
+ elif name_lower == 'x-trace-id':
+ trace_id = value
+ elif name_lower == 'x-request-flow-error':
+ flow_error = value
+
+ if request_id:
+ print(f"X-Request-ID: {request_id}")
+ if trace_id:
+ print(f"X-Trace-ID: {trace_id}")
+ if flow_error:
+ print(f"X-Request-Flow-Error: {flow_error}")
+
+ # Log error body if available
+ body = getattr(exception, 'body', None)
+ if body:
+ print("=== API ERROR RESPONSE ===")
+ print(f"Error Body: {body}")
+
+ print("============================")
+
+
+def with_error_handling(func: Callable) -> Callable:
+ """
+ Decorator that automatically parses API exceptions into custom SCM exceptions.
+
+ Wraps API methods to catch OpenAPI-generated exceptions and convert them
+ to specific SCM exception types (NameNotUniqueError, ObjectNotPresentError, etc.)
+
+ The decorator preserves the original exception chain using 'raise ... from ...'
+ so users can still access the original ApiException if needed.
+
+ Example:
+ @with_error_handling
+ def create_addresses(self, addresses=None, **kwargs):
+ # Method implementation
+ ...
+
+ Usage:
+ from scm.objects.api.addresses_api import AddressesApi
+ from scm.exceptions import NameNotUniqueError, ObjectNotPresentError
+
+ api = AddressesApi(client.objects.api_client)
+
+ try:
+ address = api.create_addresses(data)
+ except NameNotUniqueError as e:
+ print(f"Address '{e.object_name}' already exists")
+ except ObjectNotPresentError as e:
+ print(f"Object not found: {e}")
+ """
+ @wraps(func)
+ def wrapper(*args, **kwargs) -> Any:
+ try:
+ return func(*args, **kwargs)
+ except Exception as e:
+ # Check if it's an API exception that we should parse
+ if hasattr(e, 'status') and hasattr(e, 'body'):
+ # Log response headers for debugging (X-Request-ID, X-Trace-ID, etc.)
+ _log_error_headers(e)
+ # This is an OpenAPI ApiException - parse it
+ custom_exception = ErrorHandler.parse_exception(e)
+ # Raise custom exception with original exception as cause
+ raise custom_exception from e
+ else:
+ # Not an API exception, re-raise as-is
+ raise
+
+ return wrapper
diff --git a/scm/deployment_services/__init__.py b/scm/deployment_services/__init__.py
new file mode 100644
index 00000000..1f452aa3
--- /dev/null
+++ b/scm/deployment_services/__init__.py
@@ -0,0 +1,82 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from scm.deployment_services.api.application_defaults_api import ApplicationDefaultsApi
+from scm.deployment_services.api.bgp_routing_api import BGPRoutingApi
+from scm.deployment_services.api.bandwidth_allocations_api import BandwidthAllocationsApi
+from scm.deployment_services.api.internal_dns_servers_api import InternalDNSServersApi
+from scm.deployment_services.api.network_locations_api import NetworkLocationsApi
+from scm.deployment_services.api.remote_networks_api import RemoteNetworksApi
+from scm.deployment_services.api.service_connection_groups_api import ServiceConnectionGroupsApi
+from scm.deployment_services.api.service_connections_api import ServiceConnectionsApi
+from scm.deployment_services.api.shared_infrastructure_settings_api import SharedInfrastructureSettingsApi
+from scm.deployment_services.api.sites_api import SitesApi
+from scm.deployment_services.api.traffic_steering_rules_api import TrafficSteeringRulesApi
+
+# import ApiClient
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.api_client import ApiClient
+from scm.deployment_services.configuration import Configuration
+from scm.deployment_services.exceptions import OpenApiException
+from scm.deployment_services.exceptions import ApiTypeError
+from scm.deployment_services.exceptions import ApiValueError
+from scm.deployment_services.exceptions import ApiKeyError
+from scm.deployment_services.exceptions import ApiAttributeError
+from scm.deployment_services.exceptions import ApiException
+
+# import models into sdk package
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+from scm.deployment_services.models.bandwidth_allocations_list_response import BandwidthAllocationsListResponse
+from scm.deployment_services.models.bandwidth_allocations_qos import BandwidthAllocationsQos
+from scm.deployment_services.models.bgp_routing import BgpRouting
+from scm.deployment_services.models.bgp_routing_routing_preference import BgpRoutingRoutingPreference
+from scm.deployment_services.models.edit_shared_infrastructure_settings import EditSharedInfrastructureSettings
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_application_blocks import EditSharedInfrastructureSettingsConnectorApplicationBlocks
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_connector_blocks import EditSharedInfrastructureSettingsConnectorConnectorBlocks
+from scm.deployment_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.deployment_services.models.generic_error import GenericError
+from scm.deployment_services.models.internal_dns_servers_list_response import InternalDNSServersListResponse
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+from scm.deployment_services.models.locations import Locations
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner import RemoteNetworksEcmpTunnelsInner
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner_protocol import RemoteNetworksEcmpTunnelsInnerProtocol
+from scm.deployment_services.models.remote_networks_list_response import RemoteNetworksListResponse
+from scm.deployment_services.models.remote_networks_protocol import RemoteNetworksProtocol
+from scm.deployment_services.models.remote_networks_protocol_bgp import RemoteNetworksProtocolBgp
+from scm.deployment_services.models.remote_networks_protocol_bgp_peer import RemoteNetworksProtocolBgpPeer
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from scm.deployment_services.models.service_connection_groups_list_response import ServiceConnectionGroupsListResponse
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.deployment_services.models.service_connections_bgp_peer import ServiceConnectionsBgpPeer
+from scm.deployment_services.models.service_connections_list_response import ServiceConnectionsListResponse
+from scm.deployment_services.models.service_connections_protocol import ServiceConnectionsProtocol
+from scm.deployment_services.models.service_connections_protocol_bgp import ServiceConnectionsProtocolBgp
+from scm.deployment_services.models.service_connections_qos import ServiceConnectionsQos
+from scm.deployment_services.models.shared_infrastructure_settings import SharedInfrastructureSettings
+from scm.deployment_services.models.sites import Sites
+from scm.deployment_services.models.sites_list_response import SitesListResponse
+from scm.deployment_services.models.sites_members_inner import SitesMembersInner
+from scm.deployment_services.models.sites_qos import SitesQos
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from scm.deployment_services.models.traffic_steering_rules_action import TrafficSteeringRulesAction
+from scm.deployment_services.models.traffic_steering_rules_action_forward import TrafficSteeringRulesActionForward
+from scm.deployment_services.models.traffic_steering_rules_action_forward_forward import TrafficSteeringRulesActionForwardForward
+from scm.deployment_services.models.traffic_steering_rules_list_response import TrafficSteeringRulesListResponse
diff --git a/scm/deployment_services/api/__init__.py b/scm/deployment_services/api/__init__.py
new file mode 100644
index 00000000..06eccc8e
--- /dev/null
+++ b/scm/deployment_services/api/__init__.py
@@ -0,0 +1,15 @@
+# flake8: noqa
+
+# import apis into api package
+from scm.deployment_services.api.application_defaults_api import ApplicationDefaultsApi
+from scm.deployment_services.api.bgp_routing_api import BGPRoutingApi
+from scm.deployment_services.api.bandwidth_allocations_api import BandwidthAllocationsApi
+from scm.deployment_services.api.internal_dns_servers_api import InternalDNSServersApi
+from scm.deployment_services.api.network_locations_api import NetworkLocationsApi
+from scm.deployment_services.api.remote_networks_api import RemoteNetworksApi
+from scm.deployment_services.api.service_connection_groups_api import ServiceConnectionGroupsApi
+from scm.deployment_services.api.service_connections_api import ServiceConnectionsApi
+from scm.deployment_services.api.shared_infrastructure_settings_api import SharedInfrastructureSettingsApi
+from scm.deployment_services.api.sites_api import SitesApi
+from scm.deployment_services.api.traffic_steering_rules_api import TrafficSteeringRulesApi
+
diff --git a/scm/deployment_services/api/application_defaults_api.py b/scm/deployment_services/api/application_defaults_api.py
new file mode 100644
index 00000000..6876a9fc
--- /dev/null
+++ b/scm/deployment_services/api/application_defaults_api.py
@@ -0,0 +1,299 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ApplicationDefaultsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_application_defaults(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Create application defaults
+
+ Create Prisma Access application defaults. *These application defaults are normally created in the UI. This endpoint is necessary for customers that do not use the UI to create these application defaults such as certificates and configuration nodes. This endpoint will be deprecated once the UI dependencies have been eliminated.*
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_application_defaults_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_application_defaults_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Create application defaults
+
+ Create Prisma Access application defaults. *These application defaults are normally created in the UI. This endpoint is necessary for customers that do not use the UI to create these application defaults such as certificates and configuration nodes. This endpoint will be deprecated once the UI dependencies have been eliminated.*
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_application_defaults_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_application_defaults_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create application defaults
+
+ Create Prisma Access application defaults. *These application defaults are normally created in the UI. This endpoint is necessary for customers that do not use the UI to create these application defaults such as certificates and configuration nodes. This endpoint will be deprecated once the UI dependencies have been eliminated.*
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_application_defaults_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_application_defaults_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/enable',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/bandwidth_allocations_api.py b/scm/deployment_services/api/bandwidth_allocations_api.py
new file mode 100644
index 00000000..3bac59d8
--- /dev/null
+++ b/scm/deployment_services/api/bandwidth_allocations_api.py
@@ -0,0 +1,1217 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+from scm.deployment_services.models.bandwidth_allocations_list_response import BandwidthAllocationsListResponse
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BandwidthAllocationsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_bandwidth_allocations(
+ self,
+ bandwidth_allocations: Annotated[Optional[BandwidthAllocations], Field(description="The `bandwidth-allocations` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BandwidthAllocations:
+ """Create a bandwidth allocation
+
+ Create a new bandwidth allocation.
+
+ :param bandwidth_allocations: The `bandwidth-allocations` resource definition.
+ :type bandwidth_allocations: BandwidthAllocations
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bandwidth_allocations_serialize(
+ bandwidth_allocations=bandwidth_allocations,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BandwidthAllocations",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_bandwidth_allocations_with_http_info(
+ self,
+ bandwidth_allocations: Annotated[Optional[BandwidthAllocations], Field(description="The `bandwidth-allocations` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BandwidthAllocations]:
+ """Create a bandwidth allocation
+
+ Create a new bandwidth allocation.
+
+ :param bandwidth_allocations: The `bandwidth-allocations` resource definition.
+ :type bandwidth_allocations: BandwidthAllocations
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bandwidth_allocations_serialize(
+ bandwidth_allocations=bandwidth_allocations,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BandwidthAllocations",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_bandwidth_allocations_without_preload_content(
+ self,
+ bandwidth_allocations: Annotated[Optional[BandwidthAllocations], Field(description="The `bandwidth-allocations` resource definition.")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a bandwidth allocation
+
+ Create a new bandwidth allocation.
+
+ :param bandwidth_allocations: The `bandwidth-allocations` resource definition.
+ :type bandwidth_allocations: BandwidthAllocations
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bandwidth_allocations_serialize(
+ bandwidth_allocations=bandwidth_allocations,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BandwidthAllocations",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_bandwidth_allocations_serialize(
+ self,
+ bandwidth_allocations,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bandwidth_allocations is not None:
+ _body_params = bandwidth_allocations
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/bandwidth-allocations',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bandwidth_allocations(
+ self,
+ name: Annotated[StrictStr, Field(description="The name of the aggregated bandwidth region")],
+ spn_name_list: Annotated[StrictStr, Field(description="Comma separated of the spn_name_list name per region")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a bandwidth allocation
+
+ Delete a bandwidth allocation.
+
+ :param name: The name of the aggregated bandwidth region (required)
+ :type name: str
+ :param spn_name_list: Comma separated of the spn_name_list name per region (required)
+ :type spn_name_list: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bandwidth_allocations_serialize(
+ name=name,
+ spn_name_list=spn_name_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bandwidth_allocations_with_http_info(
+ self,
+ name: Annotated[StrictStr, Field(description="The name of the aggregated bandwidth region")],
+ spn_name_list: Annotated[StrictStr, Field(description="Comma separated of the spn_name_list name per region")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a bandwidth allocation
+
+ Delete a bandwidth allocation.
+
+ :param name: The name of the aggregated bandwidth region (required)
+ :type name: str
+ :param spn_name_list: Comma separated of the spn_name_list name per region (required)
+ :type spn_name_list: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bandwidth_allocations_serialize(
+ name=name,
+ spn_name_list=spn_name_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bandwidth_allocations_without_preload_content(
+ self,
+ name: Annotated[StrictStr, Field(description="The name of the aggregated bandwidth region")],
+ spn_name_list: Annotated[StrictStr, Field(description="Comma separated of the spn_name_list name per region")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a bandwidth allocation
+
+ Delete a bandwidth allocation.
+
+ :param name: The name of the aggregated bandwidth region (required)
+ :type name: str
+ :param spn_name_list: Comma separated of the spn_name_list name per region (required)
+ :type spn_name_list: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bandwidth_allocations_serialize(
+ name=name,
+ spn_name_list=spn_name_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_bandwidth_allocations_serialize(
+ self,
+ name,
+ spn_name_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if spn_name_list is not None:
+
+ _query_params.append(('spn_name_list', spn_name_list))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/bandwidth-allocations',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_bandwidth_allocations(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BandwidthAllocationsListResponse:
+ """List bandwidth regions
+
+ Retrieve a list of bandwidth regions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bandwidth_allocations_serialize(
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BandwidthAllocationsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_bandwidth_allocations_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BandwidthAllocationsListResponse]:
+ """List bandwidth regions
+
+ Retrieve a list of bandwidth regions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bandwidth_allocations_serialize(
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BandwidthAllocationsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_bandwidth_allocations_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List bandwidth regions
+
+ Retrieve a list of bandwidth regions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bandwidth_allocations_serialize(
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BandwidthAllocationsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_bandwidth_allocations_serialize(
+ self,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bandwidth-allocations',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bandwidth_allocations(
+ self,
+ bandwidth_allocations: Annotated[Optional[BandwidthAllocations], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BandwidthAllocations:
+ """Update a bandwidth allocation
+
+ Update an existing bandwidth allocation.
+
+ :param bandwidth_allocations: OK
+ :type bandwidth_allocations: BandwidthAllocations
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bandwidth_allocations_serialize(
+ bandwidth_allocations=bandwidth_allocations,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BandwidthAllocations",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bandwidth_allocations_with_http_info(
+ self,
+ bandwidth_allocations: Annotated[Optional[BandwidthAllocations], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BandwidthAllocations]:
+ """Update a bandwidth allocation
+
+ Update an existing bandwidth allocation.
+
+ :param bandwidth_allocations: OK
+ :type bandwidth_allocations: BandwidthAllocations
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bandwidth_allocations_serialize(
+ bandwidth_allocations=bandwidth_allocations,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BandwidthAllocations",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bandwidth_allocations_without_preload_content(
+ self,
+ bandwidth_allocations: Annotated[Optional[BandwidthAllocations], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a bandwidth allocation
+
+ Update an existing bandwidth allocation.
+
+ :param bandwidth_allocations: OK
+ :type bandwidth_allocations: BandwidthAllocations
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bandwidth_allocations_serialize(
+ bandwidth_allocations=bandwidth_allocations,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BandwidthAllocations",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_bandwidth_allocations_serialize(
+ self,
+ bandwidth_allocations,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bandwidth_allocations is not None:
+ _body_params = bandwidth_allocations
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bandwidth-allocations',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/bgp_routing_api.py b/scm/deployment_services/api/bgp_routing_api.py
new file mode 100644
index 00000000..1f234dfe
--- /dev/null
+++ b/scm/deployment_services/api/bgp_routing_api.py
@@ -0,0 +1,595 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.bgp_routing import BgpRouting
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BGPRoutingApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_routing(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouting:
+ """Get BGP routing settings
+
+ Get Service Connection BGP routing settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_routing_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouting",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_routing_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouting]:
+ """Get BGP routing settings
+
+ Get Service Connection BGP routing settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_routing_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouting",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_routing_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get BGP routing settings
+
+ Get Service Connection BGP routing settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_routing_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouting",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_bgp_routing_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-routing',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_routing(
+ self,
+ bgp_routing: Annotated[Optional[BgpRouting], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouting:
+ """Update BGP routing settings
+
+ Update Service Connection BGP routing settings.
+
+ :param bgp_routing: OK
+ :type bgp_routing: BgpRouting
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_routing_serialize(
+ bgp_routing=bgp_routing,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouting",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_routing_with_http_info(
+ self,
+ bgp_routing: Annotated[Optional[BgpRouting], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouting]:
+ """Update BGP routing settings
+
+ Update Service Connection BGP routing settings.
+
+ :param bgp_routing: OK
+ :type bgp_routing: BgpRouting
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_routing_serialize(
+ bgp_routing=bgp_routing,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouting",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_routing_without_preload_content(
+ self,
+ bgp_routing: Annotated[Optional[BgpRouting], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update BGP routing settings
+
+ Update Service Connection BGP routing settings.
+
+ :param bgp_routing: OK
+ :type bgp_routing: BgpRouting
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_routing_serialize(
+ bgp_routing=bgp_routing,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouting",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_bgp_routing_serialize(
+ self,
+ bgp_routing,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_routing is not None:
+ _body_params = bgp_routing
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bgp-routing',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/internal_dns_servers_api.py b/scm/deployment_services/api/internal_dns_servers_api.py
new file mode 100644
index 00000000..6e1584a6
--- /dev/null
+++ b/scm/deployment_services/api/internal_dns_servers_api.py
@@ -0,0 +1,1556 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.internal_dns_servers_list_response import InternalDNSServersListResponse
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class InternalDNSServersApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_internal_dns_servers(
+ self,
+ internal_dns_servers: Annotated[Optional[InternalDnsServers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InternalDnsServers:
+ """Create a internal DNS server
+
+ Create a new internal DNS server.
+
+ :param internal_dns_servers: Created
+ :type internal_dns_servers: InternalDnsServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_internal_dns_servers_serialize(
+ internal_dns_servers=internal_dns_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_internal_dns_servers_with_http_info(
+ self,
+ internal_dns_servers: Annotated[Optional[InternalDnsServers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InternalDnsServers]:
+ """Create a internal DNS server
+
+ Create a new internal DNS server.
+
+ :param internal_dns_servers: Created
+ :type internal_dns_servers: InternalDnsServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_internal_dns_servers_serialize(
+ internal_dns_servers=internal_dns_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_internal_dns_servers_without_preload_content(
+ self,
+ internal_dns_servers: Annotated[Optional[InternalDnsServers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a internal DNS server
+
+ Create a new internal DNS server.
+
+ :param internal_dns_servers: Created
+ :type internal_dns_servers: InternalDnsServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_internal_dns_servers_serialize(
+ internal_dns_servers=internal_dns_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_internal_dns_servers_serialize(
+ self,
+ internal_dns_servers,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if internal_dns_servers is not None:
+ _body_params = internal_dns_servers
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/internal-dns-servers',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_internal_dns_servers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an internal DNS server
+
+ Delete an internal DNS server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_internal_dns_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_internal_dns_servers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an internal DNS server
+
+ Delete an internal DNS server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_internal_dns_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_internal_dns_servers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an internal DNS server
+
+ Delete an internal DNS server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_internal_dns_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_internal_dns_servers_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/internal-dns-servers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_internal_dns_servers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InternalDnsServers:
+ """Get an internal DNS server
+
+ Get an existing internal DNS server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_internal_dns_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_internal_dns_servers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InternalDnsServers]:
+ """Get an internal DNS server
+
+ Get an existing internal DNS server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_internal_dns_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_internal_dns_servers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an internal DNS server
+
+ Get an existing internal DNS server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_internal_dns_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_internal_dns_servers_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/internal-dns-servers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_internal_dns_servers(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InternalDNSServersListResponse:
+ """List internal DNS servers
+
+ Retrieve a list of internal DNS servers.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_internal_dns_servers_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDNSServersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_internal_dns_servers_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InternalDNSServersListResponse]:
+ """List internal DNS servers
+
+ Retrieve a list of internal DNS servers.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_internal_dns_servers_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDNSServersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_internal_dns_servers_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List internal DNS servers
+
+ Retrieve a list of internal DNS servers.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_internal_dns_servers_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDNSServersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_internal_dns_servers_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/internal-dns-servers',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_internal_dns_servers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ internal_dns_servers: Annotated[Optional[InternalDnsServers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InternalDnsServers:
+ """Update an internal DNS server
+
+ Update an existing internal dns server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param internal_dns_servers: OK
+ :type internal_dns_servers: InternalDnsServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_internal_dns_servers_by_id_serialize(
+ id=id,
+ internal_dns_servers=internal_dns_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_internal_dns_servers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ internal_dns_servers: Annotated[Optional[InternalDnsServers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InternalDnsServers]:
+ """Update an internal DNS server
+
+ Update an existing internal dns server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param internal_dns_servers: OK
+ :type internal_dns_servers: InternalDnsServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_internal_dns_servers_by_id_serialize(
+ id=id,
+ internal_dns_servers=internal_dns_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_internal_dns_servers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ internal_dns_servers: Annotated[Optional[InternalDnsServers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an internal DNS server
+
+ Update an existing internal dns server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param internal_dns_servers: OK
+ :type internal_dns_servers: InternalDnsServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_internal_dns_servers_by_id_serialize(
+ id=id,
+ internal_dns_servers=internal_dns_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InternalDnsServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_internal_dns_servers(
+ self,
+ name: str,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single internal_dns_servers object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name.
+
+ Args:
+ name: The name of the object to fetch
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_internal_dns_servers(name="my-object")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_internal_dns_servers(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_internal_dns_servers_by_id_serialize(
+ self,
+ id,
+ internal_dns_servers,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if internal_dns_servers is not None:
+ _body_params = internal_dns_servers
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/internal-dns-servers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/network_locations_api.py b/scm/deployment_services/api/network_locations_api.py
new file mode 100644
index 00000000..65b6bc89
--- /dev/null
+++ b/scm/deployment_services/api/network_locations_api.py
@@ -0,0 +1,304 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from typing import List
+from scm.deployment_services.models.locations import Locations
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class NetworkLocationsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def list_locations(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[Locations]:
+ """List locations
+
+ Retrieve a list of Prisma Access locations.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_locations_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[Locations]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_locations_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[Locations]]:
+ """List locations
+
+ Retrieve a list of Prisma Access locations.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_locations_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[Locations]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_locations_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List locations
+
+ Retrieve a list of Prisma Access locations.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_locations_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[Locations]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_locations_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/locations',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/remote_networks_api.py b/scm/deployment_services/api/remote_networks_api.py
new file mode 100644
index 00000000..ea594d5e
--- /dev/null
+++ b/scm/deployment_services/api/remote_networks_api.py
@@ -0,0 +1,1585 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.deployment_services.models.remote_networks_list_response import RemoteNetworksListResponse
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class RemoteNetworksApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_remote_networks(
+ self,
+ remote_networks: Annotated[Optional[RemoteNetworks], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RemoteNetworks:
+ """Create a remote network
+
+ Create a new remote network.
+
+ :param remote_networks: Created
+ :type remote_networks: RemoteNetworks
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_remote_networks_serialize(
+ remote_networks=remote_networks,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_remote_networks_with_http_info(
+ self,
+ remote_networks: Annotated[Optional[RemoteNetworks], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RemoteNetworks]:
+ """Create a remote network
+
+ Create a new remote network.
+
+ :param remote_networks: Created
+ :type remote_networks: RemoteNetworks
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_remote_networks_serialize(
+ remote_networks=remote_networks,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_remote_networks_without_preload_content(
+ self,
+ remote_networks: Annotated[Optional[RemoteNetworks], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a remote network
+
+ Create a new remote network.
+
+ :param remote_networks: Created
+ :type remote_networks: RemoteNetworks
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_remote_networks_serialize(
+ remote_networks=remote_networks,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_remote_networks_serialize(
+ self,
+ remote_networks,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if remote_networks is not None:
+ _body_params = remote_networks
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/remote-networks',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_remote_networks_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a remote network
+
+ Delete a remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_remote_networks_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_remote_networks_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a remote network
+
+ Delete a remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_remote_networks_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_remote_networks_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a remote network
+
+ Delete a remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_remote_networks_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_remote_networks_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/remote-networks/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_remote_networks_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RemoteNetworks:
+ """Get a remote network
+
+ Get an existing remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_remote_networks_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_remote_networks_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RemoteNetworks]:
+ """Get a remote network
+
+ Get an existing remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_remote_networks_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_remote_networks_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a remote network
+
+ Get an existing remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_remote_networks_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_remote_networks_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/remote-networks/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_remote_networks(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RemoteNetworksListResponse:
+ """List remote networks
+
+ Retrieve a list of remote networks.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_remote_networks_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworksListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_remote_networks_with_http_info(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RemoteNetworksListResponse]:
+ """List remote networks
+
+ Retrieve a list of remote networks.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_remote_networks_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworksListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_remote_networks_without_preload_content(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List remote networks
+
+ Retrieve a list of remote networks.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_remote_networks_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworksListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_remote_networks_serialize(
+ self,
+ folder,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/remote-networks',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_remote_networks_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ remote_networks: Annotated[Optional[RemoteNetworks], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RemoteNetworks:
+ """Update a remote network
+
+ Update an existing remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param remote_networks: OK
+ :type remote_networks: RemoteNetworks
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_remote_networks_by_id_serialize(
+ id=id,
+ remote_networks=remote_networks,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_remote_networks_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ remote_networks: Annotated[Optional[RemoteNetworks], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RemoteNetworks]:
+ """Update a remote network
+
+ Update an existing remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param remote_networks: OK
+ :type remote_networks: RemoteNetworks
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_remote_networks_by_id_serialize(
+ id=id,
+ remote_networks=remote_networks,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_remote_networks_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ remote_networks: Annotated[Optional[RemoteNetworks], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a remote network
+
+ Update an existing remote network.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param remote_networks: OK
+ :type remote_networks: RemoteNetworks
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_remote_networks_by_id_serialize(
+ id=id,
+ remote_networks=remote_networks,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RemoteNetworks",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_remote_networks(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single remote_networks object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_remote_networks(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_remote_networks(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_remote_networks_by_id_serialize(
+ self,
+ id,
+ remote_networks,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if remote_networks is not None:
+ _body_params = remote_networks
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/remote-networks/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/service_connection_groups_api.py b/scm/deployment_services/api/service_connection_groups_api.py
new file mode 100644
index 00000000..082faf12
--- /dev/null
+++ b/scm/deployment_services/api/service_connection_groups_api.py
@@ -0,0 +1,1585 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from scm.deployment_services.models.service_connection_groups_list_response import ServiceConnectionGroupsListResponse
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ServiceConnectionGroupsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_connection_groups(
+ self,
+ service_connection_groups: Annotated[Optional[ServiceConnectionGroups], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnectionGroups:
+ """Create a service connection group
+
+ Create a new service connection group.
+
+ :param service_connection_groups: Created
+ :type service_connection_groups: ServiceConnectionGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_connection_groups_serialize(
+ service_connection_groups=service_connection_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_connection_groups_with_http_info(
+ self,
+ service_connection_groups: Annotated[Optional[ServiceConnectionGroups], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnectionGroups]:
+ """Create a service connection group
+
+ Create a new service connection group.
+
+ :param service_connection_groups: Created
+ :type service_connection_groups: ServiceConnectionGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_connection_groups_serialize(
+ service_connection_groups=service_connection_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_connection_groups_without_preload_content(
+ self,
+ service_connection_groups: Annotated[Optional[ServiceConnectionGroups], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a service connection group
+
+ Create a new service connection group.
+
+ :param service_connection_groups: Created
+ :type service_connection_groups: ServiceConnectionGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_connection_groups_serialize(
+ service_connection_groups=service_connection_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_service_connection_groups_serialize(
+ self,
+ service_connection_groups,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_connection_groups is not None:
+ _body_params = service_connection_groups
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/service-connection-groups',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_connection_groups_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a service connection group
+
+ Delete a service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_connection_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_connection_groups_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a service connection group
+
+ Delete a service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_connection_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_connection_groups_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a service connection group
+
+ Delete a service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_connection_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_service_connection_groups_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/service-connection-groups/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_connection_groups_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnectionGroups:
+ """Get a service connection group
+
+ Get an existing service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_connection_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_connection_groups_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnectionGroups]:
+ """Get a service connection group
+
+ Get an existing service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_connection_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_connection_groups_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a service connection group
+
+ Get an existing service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_connection_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_service_connection_groups_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-connection-groups/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_connection_groups(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnectionGroupsListResponse:
+ """List service connection groups
+
+ Retrieve a list of service connection groups.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_connection_groups_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroupsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_connection_groups_with_http_info(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnectionGroupsListResponse]:
+ """List service connection groups
+
+ Retrieve a list of service connection groups.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_connection_groups_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroupsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_connection_groups_without_preload_content(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List service connection groups
+
+ Retrieve a list of service connection groups.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_connection_groups_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroupsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_service_connection_groups_serialize(
+ self,
+ folder,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-connection-groups',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_connection_groups_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_connection_groups: Annotated[Optional[ServiceConnectionGroups], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnectionGroups:
+ """Update a service connection group
+
+ Update an existing service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_connection_groups: OK
+ :type service_connection_groups: ServiceConnectionGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_connection_groups_by_id_serialize(
+ id=id,
+ service_connection_groups=service_connection_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_connection_groups_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_connection_groups: Annotated[Optional[ServiceConnectionGroups], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnectionGroups]:
+ """Update a service connection group
+
+ Update an existing service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_connection_groups: OK
+ :type service_connection_groups: ServiceConnectionGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_connection_groups_by_id_serialize(
+ id=id,
+ service_connection_groups=service_connection_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_connection_groups_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_connection_groups: Annotated[Optional[ServiceConnectionGroups], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a service connection group
+
+ Update an existing service connection group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_connection_groups: OK
+ :type service_connection_groups: ServiceConnectionGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_connection_groups_by_id_serialize(
+ id=id,
+ service_connection_groups=service_connection_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_service_connection_groups(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single service_connection_groups object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_service_connection_groups(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_service_connection_groups(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_service_connection_groups_by_id_serialize(
+ self,
+ id,
+ service_connection_groups,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_connection_groups is not None:
+ _body_params = service_connection_groups
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/service-connection-groups/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/service_connections_api.py b/scm/deployment_services/api/service_connections_api.py
new file mode 100644
index 00000000..a11fe2d2
--- /dev/null
+++ b/scm/deployment_services/api/service_connections_api.py
@@ -0,0 +1,1585 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.deployment_services.models.service_connections_list_response import ServiceConnectionsListResponse
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ServiceConnectionsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_connections(
+ self,
+ service_connections: Annotated[Optional[ServiceConnections], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnections:
+ """Create a service connection
+
+ Create a new service connection.
+
+ :param service_connections: Created
+ :type service_connections: ServiceConnections
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_connections_serialize(
+ service_connections=service_connections,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_connections_with_http_info(
+ self,
+ service_connections: Annotated[Optional[ServiceConnections], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnections]:
+ """Create a service connection
+
+ Create a new service connection.
+
+ :param service_connections: Created
+ :type service_connections: ServiceConnections
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_connections_serialize(
+ service_connections=service_connections,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_connections_without_preload_content(
+ self,
+ service_connections: Annotated[Optional[ServiceConnections], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a service connection
+
+ Create a new service connection.
+
+ :param service_connections: Created
+ :type service_connections: ServiceConnections
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_connections_serialize(
+ service_connections=service_connections,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_service_connections_serialize(
+ self,
+ service_connections,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_connections is not None:
+ _body_params = service_connections
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/service-connections',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_connections_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a service connection
+
+ Delete a service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_connections_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_connections_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a service connection
+
+ Delete a service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_connections_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_connections_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a service connection
+
+ Delete a service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_connections_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_service_connections_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/service-connections/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_connections_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnections:
+ """Get a service connection
+
+ Get an existing service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_connections_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_connections_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnections]:
+ """Get a service connection
+
+ Get an existing service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_connections_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_connections_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a service connection
+
+ Get an existing service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_connections_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_service_connections_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-connections/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_connections(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnectionsListResponse:
+ """List service connections
+
+ Retrieve a list of service connections.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_connections_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_connections_with_http_info(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnectionsListResponse]:
+ """List service connections
+
+ Retrieve a list of service connections.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_connections_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_connections_without_preload_content(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List service connections
+
+ Retrieve a list of service connections.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_connections_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnectionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_service_connections_serialize(
+ self,
+ folder,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-connections',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_connections_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_connections: Annotated[Optional[ServiceConnections], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceConnections:
+ """Update a service connection
+
+ Update an existing service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_connections: OK
+ :type service_connections: ServiceConnections
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_connections_by_id_serialize(
+ id=id,
+ service_connections=service_connections,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_connections_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_connections: Annotated[Optional[ServiceConnections], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceConnections]:
+ """Update a service connection
+
+ Update an existing service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_connections: OK
+ :type service_connections: ServiceConnections
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_connections_by_id_serialize(
+ id=id,
+ service_connections=service_connections,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_connections_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_connections: Annotated[Optional[ServiceConnections], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a service connection
+
+ Update an existing service connection.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_connections: OK
+ :type service_connections: ServiceConnections
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_connections_by_id_serialize(
+ id=id,
+ service_connections=service_connections,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceConnections",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_service_connections(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single service_connections object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_service_connections(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_service_connections(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_service_connections_by_id_serialize(
+ self,
+ id,
+ service_connections,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_connections is not None:
+ _body_params = service_connections
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/service-connections/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/shared_infrastructure_settings_api.py b/scm/deployment_services/api/shared_infrastructure_settings_api.py
new file mode 100644
index 00000000..63e22dc5
--- /dev/null
+++ b/scm/deployment_services/api/shared_infrastructure_settings_api.py
@@ -0,0 +1,596 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.edit_shared_infrastructure_settings import EditSharedInfrastructureSettings
+from scm.deployment_services.models.shared_infrastructure_settings import SharedInfrastructureSettings
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SharedInfrastructureSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def get_shared_infrastructure_settings(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SharedInfrastructureSettings:
+ """Get shared infrastructure settings
+
+ Get the Prisma Access shared infrastructure settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_shared_infrastructure_settings_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SharedInfrastructureSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_shared_infrastructure_settings_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SharedInfrastructureSettings]:
+ """Get shared infrastructure settings
+
+ Get the Prisma Access shared infrastructure settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_shared_infrastructure_settings_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SharedInfrastructureSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_shared_infrastructure_settings_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get shared infrastructure settings
+
+ Get the Prisma Access shared infrastructure settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_shared_infrastructure_settings_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SharedInfrastructureSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_shared_infrastructure_settings_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/shared-infrastructure-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_shared_infrastructure_settings(
+ self,
+ edit_shared_infrastructure_settings: Annotated[Optional[EditSharedInfrastructureSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SharedInfrastructureSettings:
+ """Update infrastructure settings
+
+ Update the Prisma Access shared infrastructure settings.
+
+ :param edit_shared_infrastructure_settings: OK
+ :type edit_shared_infrastructure_settings: EditSharedInfrastructureSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_shared_infrastructure_settings_serialize(
+ edit_shared_infrastructure_settings=edit_shared_infrastructure_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SharedInfrastructureSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_shared_infrastructure_settings_with_http_info(
+ self,
+ edit_shared_infrastructure_settings: Annotated[Optional[EditSharedInfrastructureSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SharedInfrastructureSettings]:
+ """Update infrastructure settings
+
+ Update the Prisma Access shared infrastructure settings.
+
+ :param edit_shared_infrastructure_settings: OK
+ :type edit_shared_infrastructure_settings: EditSharedInfrastructureSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_shared_infrastructure_settings_serialize(
+ edit_shared_infrastructure_settings=edit_shared_infrastructure_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SharedInfrastructureSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_shared_infrastructure_settings_without_preload_content(
+ self,
+ edit_shared_infrastructure_settings: Annotated[Optional[EditSharedInfrastructureSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update infrastructure settings
+
+ Update the Prisma Access shared infrastructure settings.
+
+ :param edit_shared_infrastructure_settings: OK
+ :type edit_shared_infrastructure_settings: EditSharedInfrastructureSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_shared_infrastructure_settings_serialize(
+ edit_shared_infrastructure_settings=edit_shared_infrastructure_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SharedInfrastructureSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_shared_infrastructure_settings_serialize(
+ self,
+ edit_shared_infrastructure_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if edit_shared_infrastructure_settings is not None:
+ _body_params = edit_shared_infrastructure_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/shared-infrastructure-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/sites_api.py b/scm/deployment_services/api/sites_api.py
new file mode 100644
index 00000000..2415f29c
--- /dev/null
+++ b/scm/deployment_services/api/sites_api.py
@@ -0,0 +1,1585 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.sites import Sites
+from scm.deployment_services.models.sites_list_response import SitesListResponse
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SitesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_sites(
+ self,
+ sites: Annotated[Optional[Sites], Field(description="The site you want to create")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Sites:
+ """Create a site
+
+ Create a new sites.
+
+ :param sites: The site you want to create
+ :type sites: Sites
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sites_serialize(
+ sites=sites,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_sites_with_http_info(
+ self,
+ sites: Annotated[Optional[Sites], Field(description="The site you want to create")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Sites]:
+ """Create a site
+
+ Create a new sites.
+
+ :param sites: The site you want to create
+ :type sites: Sites
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sites_serialize(
+ sites=sites,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_sites_without_preload_content(
+ self,
+ sites: Annotated[Optional[Sites], Field(description="The site you want to create")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a site
+
+ Create a new sites.
+
+ :param sites: The site you want to create
+ :type sites: Sites
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sites_serialize(
+ sites=sites,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_sites_serialize(
+ self,
+ sites,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sites is not None:
+ _body_params = sites
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/sites',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sites_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a site
+
+ Delete a site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sites_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sites_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a site
+
+ Delete a site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sites_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sites_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a site
+
+ Delete a site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sites_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_sites_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/sites/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_sites_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Sites:
+ """Get a site
+
+ Get an existing site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sites_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_sites_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Sites]:
+ """Get a site
+
+ Get an existing site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sites_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_sites_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a site
+
+ Get an existing site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sites_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_sites_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sites/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_sites(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SitesListResponse:
+ """List sites
+
+ Retrieve a list of sites.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sites_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SitesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_sites_with_http_info(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SitesListResponse]:
+ """List sites
+
+ Retrieve a list of sites.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sites_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SitesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_sites_without_preload_content(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List sites
+
+ Retrieve a list of sites.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sites_serialize(
+ folder=folder,
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SitesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_sites_serialize(
+ self,
+ folder,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sites',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_sites_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sites: Annotated[Optional[Sites], Field(description="The site you want to edit")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Sites:
+ """Update a site
+
+ Update an existing site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sites: The site you want to edit
+ :type sites: Sites
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sites_by_id_serialize(
+ id=id,
+ sites=sites,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_sites_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sites: Annotated[Optional[Sites], Field(description="The site you want to edit")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Sites]:
+ """Update a site
+
+ Update an existing site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sites: The site you want to edit
+ :type sites: Sites
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sites_by_id_serialize(
+ id=id,
+ sites=sites,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_sites_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sites: Annotated[Optional[Sites], Field(description="The site you want to edit")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a site
+
+ Update an existing site.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sites: The site you want to edit
+ :type sites: Sites
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sites_by_id_serialize(
+ id=id,
+ sites=sites,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Sites",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_sites(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single sites object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_sites(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_sites(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_sites_by_id_serialize(
+ self,
+ id,
+ sites,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sites is not None:
+ _body_params = sites
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/sites/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api/traffic_steering_rules_api.py b/scm/deployment_services/api/traffic_steering_rules_api.py
new file mode 100644
index 00000000..4aeca7e8
--- /dev/null
+++ b/scm/deployment_services/api/traffic_steering_rules_api.py
@@ -0,0 +1,1602 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from scm.deployment_services.models.traffic_steering_rules_list_response import TrafficSteeringRulesListResponse
+
+from scm.deployment_services.api_client import ApiClient, RequestSerialized
+from scm.deployment_services.api_response import ApiResponse
+from scm.deployment_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TrafficSteeringRulesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_traffic_steering_rules(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ traffic_steering_rules: Annotated[Optional[TrafficSteeringRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TrafficSteeringRules:
+ """Create a traffic steering rule
+
+ Create a new Service Connection traffic steering rule.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param traffic_steering_rules: Created
+ :type traffic_steering_rules: TrafficSteeringRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_traffic_steering_rules_serialize(
+ folder=folder,
+ traffic_steering_rules=traffic_steering_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_traffic_steering_rules_with_http_info(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ traffic_steering_rules: Annotated[Optional[TrafficSteeringRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TrafficSteeringRules]:
+ """Create a traffic steering rule
+
+ Create a new Service Connection traffic steering rule.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param traffic_steering_rules: Created
+ :type traffic_steering_rules: TrafficSteeringRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_traffic_steering_rules_serialize(
+ folder=folder,
+ traffic_steering_rules=traffic_steering_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_traffic_steering_rules_without_preload_content(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ traffic_steering_rules: Annotated[Optional[TrafficSteeringRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a traffic steering rule
+
+ Create a new Service Connection traffic steering rule.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param traffic_steering_rules: Created
+ :type traffic_steering_rules: TrafficSteeringRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_traffic_steering_rules_serialize(
+ folder=folder,
+ traffic_steering_rules=traffic_steering_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_traffic_steering_rules_serialize(
+ self,
+ folder,
+ traffic_steering_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if traffic_steering_rules is not None:
+ _body_params = traffic_steering_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/traffic-steering-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_traffic_steering_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a traffic steering rule
+
+ Delete a Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_traffic_steering_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_traffic_steering_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a traffic steering rule
+
+ Delete a Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_traffic_steering_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_traffic_steering_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a traffic steering rule
+
+ Delete a Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_traffic_steering_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_traffic_steering_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/traffic-steering-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_traffic_steering_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TrafficSteeringRules:
+ """Get a traffic steering rule
+
+ Get an existing Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_traffic_steering_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_traffic_steering_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TrafficSteeringRules]:
+ """Get a traffic steering rule
+
+ Get an existing Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_traffic_steering_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_traffic_steering_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a traffic steering rule
+
+ Get an existing Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_traffic_steering_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_traffic_steering_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/traffic-steering-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_traffic_steering_rules(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TrafficSteeringRulesListResponse:
+ """List traffic steering rules
+
+ Retrieve a list of Service Connection traffic steering rules.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_traffic_steering_rules_serialize(
+ folder=folder,
+ name=name,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_traffic_steering_rules_with_http_info(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TrafficSteeringRulesListResponse]:
+ """List traffic steering rules
+
+ Retrieve a list of Service Connection traffic steering rules.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_traffic_steering_rules_serialize(
+ folder=folder,
+ name=name,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_traffic_steering_rules_without_preload_content(
+ self,
+ folder: Annotated[StrictStr, Field(description="The folder in which the resource is defined ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List traffic steering rules
+
+ Retrieve a list of Service Connection traffic steering rules.
+
+ :param folder: The folder in which the resource is defined (required)
+ :type folder: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_traffic_steering_rules_serialize(
+ folder=folder,
+ name=name,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_traffic_steering_rules_serialize(
+ self,
+ folder,
+ name,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/traffic-steering-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_traffic_steering_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ traffic_steering_rules: Annotated[Optional[TrafficSteeringRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TrafficSteeringRules:
+ """Update a traffic steering rule
+
+ Update an existing Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param traffic_steering_rules: OK
+ :type traffic_steering_rules: TrafficSteeringRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_traffic_steering_rules_by_id_serialize(
+ id=id,
+ traffic_steering_rules=traffic_steering_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_traffic_steering_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ traffic_steering_rules: Annotated[Optional[TrafficSteeringRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TrafficSteeringRules]:
+ """Update a traffic steering rule
+
+ Update an existing Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param traffic_steering_rules: OK
+ :type traffic_steering_rules: TrafficSteeringRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_traffic_steering_rules_by_id_serialize(
+ id=id,
+ traffic_steering_rules=traffic_steering_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_traffic_steering_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ traffic_steering_rules: Annotated[Optional[TrafficSteeringRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a traffic steering rule
+
+ Update an existing Service Connection traffic steering rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param traffic_steering_rules: OK
+ :type traffic_steering_rules: TrafficSteeringRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_traffic_steering_rules_by_id_serialize(
+ id=id,
+ traffic_steering_rules=traffic_steering_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrafficSteeringRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_traffic_steering_rules(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single traffic_steering_rules object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_traffic_steering_rules(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_traffic_steering_rules(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_traffic_steering_rules_by_id_serialize(
+ self,
+ id,
+ traffic_steering_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if traffic_steering_rules is not None:
+ _body_params = traffic_steering_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/traffic-steering-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/deployment_services/api_client.py b/scm/deployment_services/api_client.py
new file mode 100644
index 00000000..219b6abe
--- /dev/null
+++ b/scm/deployment_services/api_client.py
@@ -0,0 +1,798 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import datetime
+from dateutil.parser import parse
+from enum import Enum
+import decimal
+import json
+import mimetypes
+import os
+import re
+import tempfile
+
+from urllib.parse import quote
+from typing import Tuple, Optional, List, Dict, Union
+from pydantic import SecretStr
+
+from scm.deployment_services.configuration import Configuration
+from scm.deployment_services.api_response import ApiResponse, T as ApiResponseT
+import scm.deployment_services.models
+from scm.deployment_services import rest
+from scm.deployment_services.exceptions import (
+ ApiValueError,
+ ApiException,
+ BadRequestException,
+ UnauthorizedException,
+ ForbiddenException,
+ NotFoundException,
+ ServiceException
+)
+
+RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]
+
+class ApiClient:
+ """Generic API client for OpenAPI client library builds.
+
+ OpenAPI generic API client. This client handles the client-
+ server communication, and is invariant across implementations. Specifics of
+ the methods and models for each application are generated from the OpenAPI
+ templates.
+
+ :param configuration: .Configuration object for this client
+ :param header_name: a header to pass when making calls to the API.
+ :param header_value: a header value to pass when making calls to
+ the API.
+ :param cookie: a cookie to include in the header when making calls
+ to the API
+ """
+
+ PRIMITIVE_TYPES = (float, bool, bytes, str, int)
+ NATIVE_TYPES_MAPPING = {
+ 'int': int,
+ 'long': int, # TODO remove as only py3 is supported?
+ 'float': float,
+ 'str': str,
+ 'bool': bool,
+ 'date': datetime.date,
+ 'datetime': datetime.datetime,
+ 'decimal': decimal.Decimal,
+ 'object': object,
+ }
+ _pool = None
+
+ def __init__(
+ self,
+ configuration=None,
+ header_name=None,
+ header_value=None,
+ cookie=None
+ ) -> None:
+ # use default configuration if none is provided
+ if configuration is None:
+ configuration = Configuration.get_default()
+ self.configuration = configuration
+
+ self.rest_client = rest.RESTClientObject(configuration)
+ self.default_headers = {}
+ if header_name is not None:
+ self.default_headers[header_name] = header_value
+ self.cookie = cookie
+ # Set default User-Agent.
+ self.user_agent = 'OpenAPI-Generator/1.0.0/python'
+ self.client_side_validation = configuration.client_side_validation
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ pass
+
+ @property
+ def user_agent(self):
+ """User agent for this API client"""
+ return self.default_headers['User-Agent']
+
+ @user_agent.setter
+ def user_agent(self, value):
+ self.default_headers['User-Agent'] = value
+
+ def set_default_header(self, header_name, header_value):
+ self.default_headers[header_name] = header_value
+
+
+ _default = None
+
+ @classmethod
+ def get_default(cls):
+ """Return new instance of ApiClient.
+
+ This method returns newly created, based on default constructor,
+ object of ApiClient class or returns a copy of default
+ ApiClient.
+
+ :return: The ApiClient object.
+ """
+ if cls._default is None:
+ cls._default = ApiClient()
+ return cls._default
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of ApiClient.
+
+ It stores default ApiClient.
+
+ :param default: object of ApiClient.
+ """
+ cls._default = default
+
+ def param_serialize(
+ self,
+ method,
+ resource_path,
+ path_params=None,
+ query_params=None,
+ header_params=None,
+ body=None,
+ post_params=None,
+ files=None, auth_settings=None,
+ collection_formats=None,
+ _host=None,
+ _request_auth=None
+ ) -> RequestSerialized:
+
+ """Builds the HTTP request params needed by the request.
+ :param method: Method to call.
+ :param resource_path: Path to method endpoint.
+ :param path_params: Path parameters in the url.
+ :param query_params: Query parameters in the url.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param auth_settings list: Auth Settings names for the request.
+ :param files dict: key -> filename, value -> filepath,
+ for `multipart/form-data`.
+ :param collection_formats: dict of collection formats for path, query,
+ header, and post parameters.
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the authentication
+ in the spec for a single request.
+ :return: tuple of form (path, http_method, query_params, header_params,
+ body, post_params, files)
+ """
+
+ config = self.configuration
+
+ # header parameters
+ header_params = header_params or {}
+ header_params.update(self.default_headers)
+ if self.cookie:
+ header_params['Cookie'] = self.cookie
+ if header_params:
+ header_params = self.sanitize_for_serialization(header_params)
+ header_params = dict(
+ self.parameters_to_tuples(header_params,collection_formats)
+ )
+
+ # path parameters
+ if path_params:
+ path_params = self.sanitize_for_serialization(path_params)
+ path_params = self.parameters_to_tuples(
+ path_params,
+ collection_formats
+ )
+ for k, v in path_params:
+ # specified safe chars, encode everything
+ resource_path = resource_path.replace(
+ '{%s}' % k,
+ quote(str(v), safe=config.safe_chars_for_path_param)
+ )
+
+ # post parameters
+ if post_params or files:
+ post_params = post_params if post_params else []
+ post_params = self.sanitize_for_serialization(post_params)
+ post_params = self.parameters_to_tuples(
+ post_params,
+ collection_formats
+ )
+ if files:
+ post_params.extend(self.files_parameters(files))
+
+ # auth setting
+ self.update_params_for_auth(
+ header_params,
+ query_params,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=_request_auth
+ )
+
+ # body
+ if body:
+ body = self.sanitize_for_serialization(body)
+
+ # request url
+ if _host is None or self.configuration.ignore_operation_servers:
+ url = self.configuration.host + resource_path
+ else:
+ # use server/host defined in path or operation instead
+ url = _host + resource_path
+
+ # query parameters
+ if query_params:
+ query_params = self.sanitize_for_serialization(query_params)
+ url_query = self.parameters_to_url_query(
+ query_params,
+ collection_formats
+ )
+ url += "?" + url_query
+
+ return method, url, header_params, body, post_params
+
+
+ def call_api(
+ self,
+ method,
+ url,
+ header_params=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ) -> rest.RESTResponse:
+ """Makes the HTTP request (synchronous)
+ :param method: Method to call.
+ :param url: Path to method endpoint.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param _request_timeout: timeout setting for this request.
+ :return: RESTResponse
+ """
+
+ try:
+ # perform request and return response
+ response_data = self.rest_client.request(
+ method, url,
+ headers=header_params,
+ body=body, post_params=post_params,
+ _request_timeout=_request_timeout
+ )
+
+ except ApiException as e:
+ raise e
+
+ return response_data
+
+ def response_deserialize(
+ self,
+ response_data: rest.RESTResponse,
+ response_types_map: Optional[Dict[str, ApiResponseT]]=None
+ ) -> ApiResponse[ApiResponseT]:
+ """Deserializes response into an object.
+ :param response_data: RESTResponse object to be deserialized.
+ :param response_types_map: dict of response types.
+ :return: ApiResponse
+ """
+
+ msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
+ assert response_data.data is not None, msg
+
+ response_type = response_types_map.get(str(response_data.status), None)
+ if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
+ # if not found, look for '1XX', '2XX', etc.
+ response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
+
+ # deserialize response data
+ response_text = None
+ return_data = None
+ try:
+ if response_type == "bytearray":
+ return_data = response_data.data
+ elif response_type == "file":
+ return_data = self.__deserialize_file(response_data)
+ elif response_type is not None:
+ match = None
+ content_type = response_data.getheader('content-type')
+ if content_type is not None:
+ match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
+ encoding = match.group(1) if match else "utf-8"
+ response_text = response_data.data.decode(encoding)
+ return_data = self.deserialize(response_text, response_type, content_type)
+ finally:
+ if not 200 <= response_data.status <= 299:
+ raise ApiException.from_response(
+ http_resp=response_data,
+ body=response_text,
+ data=return_data,
+ )
+
+ return ApiResponse(
+ status_code = response_data.status,
+ data = return_data,
+ headers = response_data.getheaders(),
+ raw_data = response_data.data
+ )
+
+ def sanitize_for_serialization(self, obj):
+ """Builds a JSON POST object.
+
+ If obj is None, return None.
+ If obj is SecretStr, return obj.get_secret_value()
+ If obj is str, int, long, float, bool, return directly.
+ If obj is datetime.datetime, datetime.date
+ convert to string in iso8601 format.
+ If obj is decimal.Decimal return string representation.
+ If obj is list, sanitize each element in the list.
+ If obj is dict, return the dict.
+ If obj is OpenAPI model, return the properties dict.
+
+ :param obj: The data to serialize.
+ :return: The serialized form of data.
+ """
+ if obj is None:
+ return None
+ elif isinstance(obj, Enum):
+ return obj.value
+ elif isinstance(obj, SecretStr):
+ return obj.get_secret_value()
+ elif isinstance(obj, self.PRIMITIVE_TYPES):
+ return obj
+ elif isinstance(obj, list):
+ return [
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ ]
+ elif isinstance(obj, tuple):
+ return tuple(
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ )
+ elif isinstance(obj, (datetime.datetime, datetime.date)):
+ return obj.isoformat()
+ elif isinstance(obj, decimal.Decimal):
+ return str(obj)
+
+ elif isinstance(obj, dict):
+ obj_dict = obj
+ else:
+ # Convert model obj to dict except
+ # attributes `openapi_types`, `attribute_map`
+ # and attributes which value is not None.
+ # Convert attribute name to json key in
+ # model definition for request.
+ if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
+ obj_dict = obj.to_dict()
+ else:
+ obj_dict = obj.__dict__
+
+ return {
+ key: self.sanitize_for_serialization(val)
+ for key, val in obj_dict.items()
+ }
+
+ def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]):
+ """Deserializes response into an object.
+
+ :param response: RESTResponse object to be deserialized.
+ :param response_type: class literal for
+ deserialized object, or string of class name.
+ :param content_type: content type of response.
+
+ :return: deserialized object.
+ """
+
+ # fetch data from response object
+ if content_type is None:
+ try:
+ data = json.loads(response_text)
+ except ValueError:
+ data = response_text
+ elif re.match(r'^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)', content_type, re.IGNORECASE):
+ if response_text == "":
+ data = ""
+ else:
+ data = json.loads(response_text)
+ elif re.match(r'^text\/[a-z.+-]+\s*(;|$)', content_type, re.IGNORECASE):
+ data = response_text
+ else:
+ raise ApiException(
+ status=0,
+ reason="Unsupported content type: {0}".format(content_type)
+ )
+
+ return self.__deserialize(data, response_type)
+
+ def __deserialize(self, data, klass):
+ """Deserializes dict, list, str into an object.
+
+ :param data: dict, list or str.
+ :param klass: class literal, or string of class name.
+
+ :return: object.
+ """
+ if data is None:
+ return None
+
+ if isinstance(klass, str):
+ if klass.startswith('List['):
+ m = re.match(r'List\[(.*)]', klass)
+ assert m is not None, "Malformed List type definition"
+ sub_kls = m.group(1)
+ return [self.__deserialize(sub_data, sub_kls)
+ for sub_data in data]
+
+ if klass.startswith('Dict['):
+ m = re.match(r'Dict\[([^,]*), (.*)]', klass)
+ assert m is not None, "Malformed Dict type definition"
+ sub_kls = m.group(2)
+ return {k: self.__deserialize(v, sub_kls)
+ for k, v in data.items()}
+
+ # convert str to class
+ if klass in self.NATIVE_TYPES_MAPPING:
+ klass = self.NATIVE_TYPES_MAPPING[klass]
+ else:
+ klass = getattr(scm.deployment_services.models, klass)
+
+ if klass in self.PRIMITIVE_TYPES:
+ return self.__deserialize_primitive(data, klass)
+ elif klass == object:
+ return self.__deserialize_object(data)
+ elif klass == datetime.date:
+ return self.__deserialize_date(data)
+ elif klass == datetime.datetime:
+ return self.__deserialize_datetime(data)
+ elif klass == decimal.Decimal:
+ return decimal.Decimal(data)
+ elif issubclass(klass, Enum):
+ return self.__deserialize_enum(data, klass)
+ else:
+ return self.__deserialize_model(data, klass)
+
+ def parameters_to_tuples(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: Parameters as list of tuples, collections formatted
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, value) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(str(value) for value in v)))
+ else:
+ new_params.append((k, v))
+ return new_params
+
+ def parameters_to_url_query(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: URL query string (e.g. a=Hello%20World&b=123)
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if isinstance(v, bool):
+ v = str(v).lower()
+ if isinstance(v, (int, float)):
+ v = str(v)
+ if isinstance(v, dict):
+ v = json.dumps(v)
+
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, str(value)) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(quote(str(value)) for value in v))
+ )
+ else:
+ new_params.append((k, quote(str(v))))
+
+ return "&".join(["=".join(map(str, item)) for item in new_params])
+
+ def files_parameters(
+ self,
+ files: Dict[str, Union[str, bytes, List[str], List[bytes], Tuple[str, bytes]]],
+ ):
+ """Builds form parameters.
+
+ :param files: File parameters.
+ :return: Form parameters with files.
+ """
+ params = []
+ for k, v in files.items():
+ if isinstance(v, str):
+ with open(v, 'rb') as f:
+ filename = os.path.basename(f.name)
+ filedata = f.read()
+ elif isinstance(v, bytes):
+ filename = k
+ filedata = v
+ elif isinstance(v, tuple):
+ filename, filedata = v
+ elif isinstance(v, list):
+ for file_param in v:
+ params.extend(self.files_parameters({k: file_param}))
+ continue
+ else:
+ raise ValueError("Unsupported file value")
+ mimetype = (
+ mimetypes.guess_type(filename)[0]
+ or 'application/octet-stream'
+ )
+ params.append(
+ tuple([k, tuple([filename, filedata, mimetype])])
+ )
+ return params
+
+ def select_header_accept(self, accepts: List[str]) -> Optional[str]:
+ """Returns `Accept` based on an array of accepts provided.
+
+ :param accepts: List of headers.
+ :return: Accept (e.g. application/json).
+ """
+ if not accepts:
+ return None
+
+ for accept in accepts:
+ if re.search('json', accept, re.IGNORECASE):
+ return accept
+
+ return accepts[0]
+
+ def select_header_content_type(self, content_types):
+ """Returns `Content-Type` based on an array of content_types provided.
+
+ :param content_types: List of content-types.
+ :return: Content-Type (e.g. application/json).
+ """
+ if not content_types:
+ return None
+
+ for content_type in content_types:
+ if re.search('json', content_type, re.IGNORECASE):
+ return content_type
+
+ return content_types[0]
+
+ def update_params_for_auth(
+ self,
+ headers,
+ queries,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=None
+ ) -> None:
+ """Updates header and query params based on authentication setting.
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :param auth_settings: Authentication setting identifiers list.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param request_auth: if set, the provided settings will
+ override the token in the configuration.
+ """
+ if not auth_settings:
+ return
+
+ if request_auth:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ request_auth
+ )
+ else:
+ for auth in auth_settings:
+ auth_setting = self.configuration.auth_settings().get(auth)
+ if auth_setting:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ )
+
+ def _apply_auth_params(
+ self,
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ ) -> None:
+ """Updates the request parameters based on a single auth_setting
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param auth_setting: auth settings for the endpoint
+ """
+ if auth_setting['in'] == 'cookie':
+ headers['Cookie'] = auth_setting['value']
+ elif auth_setting['in'] == 'header':
+ if auth_setting['type'] != 'http-signature':
+ headers[auth_setting['key']] = auth_setting['value']
+ elif auth_setting['in'] == 'query':
+ queries.append((auth_setting['key'], auth_setting['value']))
+ else:
+ raise ApiValueError(
+ 'Authentication token must be in `query` or `header`'
+ )
+
+ def __deserialize_file(self, response):
+ """Deserializes body to file
+
+ Saves response body into a file in a temporary folder,
+ using the filename from the `Content-Disposition` header if provided.
+
+ handle file downloading
+ save response body into a tmp file and return the instance
+
+ :param response: RESTResponse.
+ :return: file path.
+ """
+ fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
+ os.close(fd)
+ os.remove(path)
+
+ content_disposition = response.getheader("Content-Disposition")
+ if content_disposition:
+ m = re.search(
+ r'filename=[\'"]?([^\'"\s]+)[\'"]?',
+ content_disposition
+ )
+ assert m is not None, "Unexpected 'content-disposition' header value"
+ filename = m.group(1)
+ path = os.path.join(os.path.dirname(path), filename)
+
+ with open(path, "wb") as f:
+ f.write(response.data)
+
+ return path
+
+ def __deserialize_primitive(self, data, klass):
+ """Deserializes string to primitive type.
+
+ :param data: str.
+ :param klass: class literal.
+
+ :return: int, long, float, str, bool.
+ """
+ try:
+ return klass(data)
+ except UnicodeEncodeError:
+ return str(data)
+ except TypeError:
+ return data
+
+ def __deserialize_object(self, value):
+ """Return an original value.
+
+ :return: object.
+ """
+ return value
+
+ def __deserialize_date(self, string):
+ """Deserializes string to date.
+
+ :param string: str.
+ :return: date.
+ """
+ try:
+ return parse(string).date()
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason="Failed to parse `{0}` as date object".format(string)
+ )
+
+ def __deserialize_datetime(self, string):
+ """Deserializes string to datetime.
+
+ The string should be in iso8601 datetime format.
+
+ :param string: str.
+ :return: datetime.
+ """
+ try:
+ return parse(string)
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as datetime object"
+ .format(string)
+ )
+ )
+
+ def __deserialize_enum(self, data, klass):
+ """Deserializes primitive type to enum.
+
+ :param data: primitive type.
+ :param klass: class literal.
+ :return: enum value.
+ """
+ try:
+ return klass(data)
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as `{1}`"
+ .format(data, klass)
+ )
+ )
+
+ def __deserialize_model(self, data, klass):
+ """Deserializes list or dict to model.
+
+ :param data: dict, list.
+ :param klass: class literal.
+ :return: model object.
+ """
+
+ return klass.from_dict(data)
diff --git a/scm/deployment_services/api_response.py b/scm/deployment_services/api_response.py
new file mode 100644
index 00000000..9bc7c11f
--- /dev/null
+++ b/scm/deployment_services/api_response.py
@@ -0,0 +1,21 @@
+"""API response object."""
+
+from __future__ import annotations
+from typing import Optional, Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+ """
+ API response object
+ """
+
+ status_code: StrictInt = Field(description="HTTP status code")
+ headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
+ data: T = Field(description="Deserialized data given the data type")
+ raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
+
+ model_config = {
+ "arbitrary_types_allowed": True
+ }
diff --git a/scm/deployment_services/configuration.py b/scm/deployment_services/configuration.py
new file mode 100644
index 00000000..839112c4
--- /dev/null
+++ b/scm/deployment_services/configuration.py
@@ -0,0 +1,471 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import copy
+import logging
+from logging import FileHandler
+import multiprocessing
+import sys
+from typing import Optional
+import urllib3
+
+import http.client as httplib
+
+JSON_SCHEMA_VALIDATION_KEYWORDS = {
+ 'multipleOf', 'maximum', 'exclusiveMaximum',
+ 'minimum', 'exclusiveMinimum', 'maxLength',
+ 'minLength', 'pattern', 'maxItems', 'minItems'
+}
+
+class Configuration:
+ """This class contains various settings of the API client.
+
+ :param host: Base url.
+ :param ignore_operation_servers
+ Boolean to ignore operation servers for the API client.
+ Config will use `host` as the base url regardless of the operation servers.
+ :param api_key: Dict to store API key(s).
+ Each entry in the dict specifies an API key.
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is the API key secret.
+ :param api_key_prefix: Dict to store API prefix (e.g. Bearer).
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is an API key prefix when generating the auth data.
+ :param username: Username for HTTP basic authentication.
+ :param password: Password for HTTP basic authentication.
+ :param access_token: Access token.
+ :param server_index: Index to servers configuration.
+ :param server_variables: Mapping with string values to replace variables in
+ templated server configuration. The validation of enums is performed for
+ variables with defined enum values before.
+ :param server_operation_index: Mapping from operation ID to an index to server
+ configuration.
+ :param server_operation_variables: Mapping from operation ID to a mapping with
+ string values to replace variables in templated server configuration.
+ The validation of enums is performed for variables with defined enum
+ values before.
+ :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
+ in PEM format.
+ :param retries: Number of retries for API requests.
+
+ :Example:
+ """
+
+ _default = None
+
+ def __init__(self, host=None,
+ api_key=None, api_key_prefix=None,
+ username=None, password=None,
+ access_token=None,
+ server_index=None, server_variables=None,
+ server_operation_index=None, server_operation_variables=None,
+ ignore_operation_servers=False,
+ ssl_ca_cert=None,
+ retries=None,
+ *,
+ debug: Optional[bool] = None
+ ) -> None:
+ """Constructor
+ """
+ self._base_path = "https://api.strata.paloaltonetworks.com/config/deployment/v1" if host is None else host
+ """Default Base url
+ """
+ self.server_index = 0 if server_index is None and host is None else server_index
+ self.server_operation_index = server_operation_index or {}
+ """Default server index
+ """
+ self.server_variables = server_variables or {}
+ self.server_operation_variables = server_operation_variables or {}
+ """Default server variables
+ """
+ self.ignore_operation_servers = ignore_operation_servers
+ """Ignore operation servers
+ """
+ self.temp_folder_path = None
+ """Temp file folder for downloading files
+ """
+ # Authentication Settings
+ self.api_key = {}
+ if api_key:
+ self.api_key = api_key
+ """dict to store API key(s)
+ """
+ self.api_key_prefix = {}
+ if api_key_prefix:
+ self.api_key_prefix = api_key_prefix
+ """dict to store API prefix (e.g. Bearer)
+ """
+ self.refresh_api_key_hook = None
+ """function hook to refresh API key if expired
+ """
+ self.username = username
+ """Username for HTTP basic authentication
+ """
+ self.password = password
+ """Password for HTTP basic authentication
+ """
+ self.access_token = access_token
+ """Access token
+ """
+ self.logger = {}
+ """Logging Settings
+ """
+ self.logger["package_logger"] = logging.getLogger("scm.deployment_services")
+ self.logger["urllib3_logger"] = logging.getLogger("urllib3")
+ self.logger_format = '%(asctime)s %(levelname)s %(message)s'
+ """Log format
+ """
+ self.logger_stream_handler = None
+ """Log stream handler
+ """
+ self.logger_file_handler: Optional[FileHandler] = None
+ """Log file handler
+ """
+ self.logger_file = None
+ """Debug file location
+ """
+ if debug is not None:
+ self.debug = debug
+ else:
+ self.__debug = False
+ """Debug switch
+ """
+
+ self.verify_ssl = True
+ """SSL/TLS verification
+ Set this to false to skip verifying SSL certificate when calling API
+ from https server.
+ """
+ self.ssl_ca_cert = ssl_ca_cert
+ """Set this to customize the certificate file to verify the peer.
+ """
+ self.cert_file = None
+ """client certificate file
+ """
+ self.key_file = None
+ """client key file
+ """
+ self.assert_hostname = None
+ """Set this to True/False to enable/disable SSL hostname verification.
+ """
+ self.tls_server_name = None
+ """SSL/TLS Server Name Indication (SNI)
+ Set this to the SNI value expected by the server.
+ """
+
+ self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
+ """urllib3 connection pool's maximum number of connections saved
+ per pool. urllib3 uses 1 connection as default value, but this is
+ not the best value when you are making a lot of possibly parallel
+ requests to the same host, which is often the case here.
+ cpu_count * 5 is used as default value to increase performance.
+ """
+
+ self.proxy: Optional[str] = None
+ """Proxy URL
+ """
+ self.proxy_headers = None
+ """Proxy headers
+ """
+ self.safe_chars_for_path_param = ''
+ """Safe chars for path_param
+ """
+ self.retries = retries
+ """Adding retries to override urllib3 default value 3
+ """
+ # Enable client side validation
+ self.client_side_validation = True
+
+ self.socket_options = None
+ """Options to pass down to the underlying urllib3 socket
+ """
+
+ self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z"
+ """datetime format
+ """
+
+ self.date_format = "%Y-%m-%d"
+ """date format
+ """
+
+ def __deepcopy__(self, memo):
+ cls = self.__class__
+ result = cls.__new__(cls)
+ memo[id(self)] = result
+ for k, v in self.__dict__.items():
+ if k not in ('logger', 'logger_file_handler'):
+ setattr(result, k, copy.deepcopy(v, memo))
+ # shallow copy of loggers
+ result.logger = copy.copy(self.logger)
+ # use setters to configure loggers
+ result.logger_file = self.logger_file
+ result.debug = self.debug
+ return result
+
+ def __setattr__(self, name, value):
+ object.__setattr__(self, name, value)
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of configuration.
+
+ It stores default configuration, which can be
+ returned by get_default_copy method.
+
+ :param default: object of Configuration
+ """
+ cls._default = default
+
+ @classmethod
+ def get_default_copy(cls):
+ """Deprecated. Please use `get_default` instead.
+
+ Deprecated. Please use `get_default` instead.
+
+ :return: The configuration object.
+ """
+ return cls.get_default()
+
+ @classmethod
+ def get_default(cls):
+ """Return the default configuration.
+
+ This method returns newly created, based on default constructor,
+ object of Configuration class or returns a copy of default
+ configuration.
+
+ :return: The configuration object.
+ """
+ if cls._default is None:
+ cls._default = Configuration()
+ return cls._default
+
+ @property
+ def logger_file(self):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ return self.__logger_file
+
+ @logger_file.setter
+ def logger_file(self, value):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ self.__logger_file = value
+ if self.__logger_file:
+ # If set logging file,
+ # then add file handler and remove stream handler.
+ self.logger_file_handler = logging.FileHandler(self.__logger_file)
+ self.logger_file_handler.setFormatter(self.logger_formatter)
+ for _, logger in self.logger.items():
+ logger.addHandler(self.logger_file_handler)
+
+ @property
+ def debug(self):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ return self.__debug
+
+ @debug.setter
+ def debug(self, value):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ self.__debug = value
+ if self.__debug:
+ # if debug status is True, turn on debug logging
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.DEBUG)
+ # turn on httplib debug
+ httplib.HTTPConnection.debuglevel = 1
+ else:
+ # if debug status is False, turn off debug logging,
+ # setting log level to default `logging.WARNING`
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.WARNING)
+ # turn off httplib debug
+ httplib.HTTPConnection.debuglevel = 0
+
+ @property
+ def logger_format(self):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ return self.__logger_format
+
+ @logger_format.setter
+ def logger_format(self, value):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ self.__logger_format = value
+ self.logger_formatter = logging.Formatter(self.__logger_format)
+
+ def get_api_key_with_prefix(self, identifier, alias=None):
+ """Gets API key (with prefix if set).
+
+ :param identifier: The identifier of apiKey.
+ :param alias: The alternative identifier of apiKey.
+ :return: The token for api key authentication.
+ """
+ if self.refresh_api_key_hook is not None:
+ self.refresh_api_key_hook(self)
+ key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
+ if key:
+ prefix = self.api_key_prefix.get(identifier)
+ if prefix:
+ return "%s %s" % (prefix, key)
+ else:
+ return key
+
+ def get_basic_auth_token(self):
+ """Gets HTTP basic authentication header (string).
+
+ :return: The token for basic HTTP authentication.
+ """
+ username = ""
+ if self.username is not None:
+ username = self.username
+ password = ""
+ if self.password is not None:
+ password = self.password
+ return urllib3.util.make_headers(
+ basic_auth=username + ':' + password
+ ).get('authorization')
+
+ def auth_settings(self):
+ """Gets Auth Settings dict for api client.
+
+ :return: The Auth Settings information dict.
+ """
+ auth = {}
+ if self.access_token is not None:
+ auth['scmOAuth'] = {
+ 'type': 'oauth2',
+ 'in': 'header',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ if self.access_token is not None:
+ auth['scmToken'] = {
+ 'type': 'bearer',
+ 'in': 'header',
+ 'format': 'JWT',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ return auth
+
+ def to_debug_report(self):
+ """Gets the essential information for debugging.
+
+ :return: The report for debugging.
+ """
+ return "Python SDK Debug Report:\n"\
+ "OS: {env}\n"\
+ "Python Version: {pyversion}\n"\
+ "Version of the API: 2.0.0\n"\
+ "SDK Package Version: 1.0.0".\
+ format(env=sys.platform, pyversion=sys.version)
+
+ def get_host_settings(self):
+ """Gets an array of host settings
+
+ :return: An array of host settings
+ """
+ return [
+ {
+ 'url': "https://api.strata.paloaltonetworks.com/config/deployment/v1",
+ 'description': "Current",
+ },
+ {
+ 'url': "https://api.sase.paloaltonetworks.com/sse/config/v1",
+ 'description': "Legacy",
+ }
+ ]
+
+ def get_host_from_settings(self, index, variables=None, servers=None):
+ """Gets host URL based on the index and variables
+ :param index: array index of the host settings
+ :param variables: hash of variable and the corresponding value
+ :param servers: an array of host settings or None
+ :return: URL based on host settings
+ """
+ if index is None:
+ return self._base_path
+
+ variables = {} if variables is None else variables
+ servers = self.get_host_settings() if servers is None else servers
+
+ try:
+ server = servers[index]
+ except IndexError:
+ raise ValueError(
+ "Invalid index {0} when selecting the host settings. "
+ "Must be less than {1}".format(index, len(servers)))
+
+ url = server['url']
+
+ # go through variables and replace placeholders
+ for variable_name, variable in server.get('variables', {}).items():
+ used_value = variables.get(
+ variable_name, variable['default_value'])
+
+ if 'enum_values' in variable \
+ and used_value not in variable['enum_values']:
+ raise ValueError(
+ "The variable `{0}` in the host URL has invalid value "
+ "{1}. Must be {2}.".format(
+ variable_name, variables[variable_name],
+ variable['enum_values']))
+
+ url = url.replace("{" + variable_name + "}", used_value)
+
+ return url
+
+ @property
+ def host(self):
+ """Return generated host."""
+ return self.get_host_from_settings(self.server_index, variables=self.server_variables)
+
+ @host.setter
+ def host(self, value):
+ """Fix base path."""
+ self._base_path = value
+ self.server_index = None
diff --git a/scm/deployment_services/docs/ApplicationDefaultsApi.md b/scm/deployment_services/docs/ApplicationDefaultsApi.md
new file mode 100644
index 00000000..18dde23b
--- /dev/null
+++ b/scm/deployment_services/docs/ApplicationDefaultsApi.md
@@ -0,0 +1,85 @@
+# scm.deployment_services.ApplicationDefaultsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_application_defaults**](ApplicationDefaultsApi.md#create_application_defaults) | **POST** /enable | Create application defaults
+
+
+# **create_application_defaults**
+> create_application_defaults()
+
+Create application defaults
+
+Create Prisma Access application defaults. *These application defaults are normally created in the UI. This endpoint is necessary for customers that do not use the UI to create these application defaults such as certificates and configuration nodes. This endpoint will be deprecated once the UI dependencies have been eliminated.*
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ApplicationDefaultsApi(api_client)
+
+ try:
+ # Create application defaults
+ api_instance.create_application_defaults()
+ except Exception as e:
+ print("Exception when calling ApplicationDefaultsApi->create_application_defaults: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/BGPRoutingApi.md b/scm/deployment_services/docs/BGPRoutingApi.md
new file mode 100644
index 00000000..f22e0dd4
--- /dev/null
+++ b/scm/deployment_services/docs/BGPRoutingApi.md
@@ -0,0 +1,173 @@
+# scm.deployment_services.BGPRoutingApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**get_bgp_routing**](BGPRoutingApi.md#get_bgp_routing) | **GET** /bgp-routing | Get BGP routing settings
+[**update_bgp_routing**](BGPRoutingApi.md#update_bgp_routing) | **PUT** /bgp-routing | Update BGP routing settings
+
+
+# **get_bgp_routing**
+> BgpRouting get_bgp_routing()
+
+Get BGP routing settings
+
+Get Service Connection BGP routing settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.bgp_routing import BgpRouting
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.BGPRoutingApi(api_client)
+
+ try:
+ # Get BGP routing settings
+ api_response = api_instance.get_bgp_routing()
+ print("The response of BGPRoutingApi->get_bgp_routing:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling BGPRoutingApi->get_bgp_routing: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**BgpRouting**](BgpRouting.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_bgp_routing**
+> BgpRouting update_bgp_routing(bgp_routing=bgp_routing)
+
+Update BGP routing settings
+
+Update Service Connection BGP routing settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.bgp_routing import BgpRouting
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.BGPRoutingApi(api_client)
+ bgp_routing = scm.deployment_services.BgpRouting() # BgpRouting | OK (optional)
+
+ try:
+ # Update BGP routing settings
+ api_response = api_instance.update_bgp_routing(bgp_routing=bgp_routing)
+ print("The response of BGPRoutingApi->update_bgp_routing:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling BGPRoutingApi->update_bgp_routing: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **bgp_routing** | [**BgpRouting**](BgpRouting.md)| OK | [optional]
+
+### Return type
+
+[**BgpRouting**](BgpRouting.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/BandwidthAllocations.md b/scm/deployment_services/docs/BandwidthAllocations.md
new file mode 100644
index 00000000..efa03d90
--- /dev/null
+++ b/scm/deployment_services/docs/BandwidthAllocations.md
@@ -0,0 +1,32 @@
+# BandwidthAllocations
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**allocated_bandwidth** | **int** | bandwidth to allocate in Mbps |
+**name** | **str** | name of the aggregated bandwidth region |
+**qos** | [**BandwidthAllocationsQos**](BandwidthAllocationsQos.md) | | [optional]
+**spn_name_list** | **List[str]** | | [optional] [default to []]
+
+## Example
+
+```python
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of BandwidthAllocations from a JSON string
+bandwidth_allocations_instance = BandwidthAllocations.from_json(json)
+# print the JSON string representation of the object
+print(BandwidthAllocations.to_json())
+
+# convert the object into a dict
+bandwidth_allocations_dict = bandwidth_allocations_instance.to_dict()
+# create an instance of BandwidthAllocations from a dict
+bandwidth_allocations_from_dict = BandwidthAllocations.from_dict(bandwidth_allocations_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/BandwidthAllocationsApi.md b/scm/deployment_services/docs/BandwidthAllocationsApi.md
new file mode 100644
index 00000000..d68fead5
--- /dev/null
+++ b/scm/deployment_services/docs/BandwidthAllocationsApi.md
@@ -0,0 +1,347 @@
+# scm.deployment_services.BandwidthAllocationsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_bandwidth_allocations**](BandwidthAllocationsApi.md#create_bandwidth_allocations) | **POST** /bandwidth-allocations | Create a bandwidth allocation
+[**delete_bandwidth_allocations**](BandwidthAllocationsApi.md#delete_bandwidth_allocations) | **DELETE** /bandwidth-allocations | Delete a bandwidth allocation
+[**list_bandwidth_allocations**](BandwidthAllocationsApi.md#list_bandwidth_allocations) | **GET** /bandwidth-allocations | List bandwidth regions
+[**update_bandwidth_allocations**](BandwidthAllocationsApi.md#update_bandwidth_allocations) | **PUT** /bandwidth-allocations | Update a bandwidth allocation
+
+
+# **create_bandwidth_allocations**
+> BandwidthAllocations create_bandwidth_allocations(bandwidth_allocations=bandwidth_allocations)
+
+Create a bandwidth allocation
+
+Create a new bandwidth allocation.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.BandwidthAllocationsApi(api_client)
+ bandwidth_allocations = scm.deployment_services.BandwidthAllocations() # BandwidthAllocations | The `bandwidth-allocations` resource definition. (optional)
+
+ try:
+ # Create a bandwidth allocation
+ api_response = api_instance.create_bandwidth_allocations(bandwidth_allocations=bandwidth_allocations)
+ print("The response of BandwidthAllocationsApi->create_bandwidth_allocations:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling BandwidthAllocationsApi->create_bandwidth_allocations: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **bandwidth_allocations** | [**BandwidthAllocations**](BandwidthAllocations.md)| The `bandwidth-allocations` resource definition. | [optional]
+
+### Return type
+
+[**BandwidthAllocations**](BandwidthAllocations.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_bandwidth_allocations**
+> delete_bandwidth_allocations(name, spn_name_list)
+
+Delete a bandwidth allocation
+
+Delete a bandwidth allocation.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.BandwidthAllocationsApi(api_client)
+ name = 'name_example' # str | The name of the aggregated bandwidth region
+ spn_name_list = 'spn_name_list_example' # str | Comma separated of the spn_name_list name per region
+
+ try:
+ # Delete a bandwidth allocation
+ api_instance.delete_bandwidth_allocations(name, spn_name_list)
+ except Exception as e:
+ print("Exception when calling BandwidthAllocationsApi->delete_bandwidth_allocations: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the aggregated bandwidth region |
+ **spn_name_list** | **str**| Comma separated of the spn_name_list name per region |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_bandwidth_allocations**
+> BandwidthAllocationsListResponse list_bandwidth_allocations(limit=limit, offset=offset)
+
+List bandwidth regions
+
+Retrieve a list of bandwidth regions.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.bandwidth_allocations_list_response import BandwidthAllocationsListResponse
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.BandwidthAllocationsApi(api_client)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List bandwidth regions
+ api_response = api_instance.list_bandwidth_allocations(limit=limit, offset=offset)
+ print("The response of BandwidthAllocationsApi->list_bandwidth_allocations:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling BandwidthAllocationsApi->list_bandwidth_allocations: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**BandwidthAllocationsListResponse**](BandwidthAllocationsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_bandwidth_allocations**
+> BandwidthAllocations update_bandwidth_allocations(bandwidth_allocations=bandwidth_allocations)
+
+Update a bandwidth allocation
+
+Update an existing bandwidth allocation.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.BandwidthAllocationsApi(api_client)
+ bandwidth_allocations = scm.deployment_services.BandwidthAllocations() # BandwidthAllocations | OK (optional)
+
+ try:
+ # Update a bandwidth allocation
+ api_response = api_instance.update_bandwidth_allocations(bandwidth_allocations=bandwidth_allocations)
+ print("The response of BandwidthAllocationsApi->update_bandwidth_allocations:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling BandwidthAllocationsApi->update_bandwidth_allocations: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **bandwidth_allocations** | [**BandwidthAllocations**](BandwidthAllocations.md)| OK | [optional]
+
+### Return type
+
+[**BandwidthAllocations**](BandwidthAllocations.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/BandwidthAllocationsListResponse.md b/scm/deployment_services/docs/BandwidthAllocationsListResponse.md
new file mode 100644
index 00000000..c47882a2
--- /dev/null
+++ b/scm/deployment_services/docs/BandwidthAllocationsListResponse.md
@@ -0,0 +1,32 @@
+# BandwidthAllocationsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[BandwidthAllocations]**](BandwidthAllocations.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.deployment_services.models.bandwidth_allocations_list_response import BandwidthAllocationsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of BandwidthAllocationsListResponse from a JSON string
+bandwidth_allocations_list_response_instance = BandwidthAllocationsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(BandwidthAllocationsListResponse.to_json())
+
+# convert the object into a dict
+bandwidth_allocations_list_response_dict = bandwidth_allocations_list_response_instance.to_dict()
+# create an instance of BandwidthAllocationsListResponse from a dict
+bandwidth_allocations_list_response_from_dict = BandwidthAllocationsListResponse.from_dict(bandwidth_allocations_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/BandwidthAllocationsQos.md b/scm/deployment_services/docs/BandwidthAllocationsQos.md
new file mode 100644
index 00000000..914a4ea6
--- /dev/null
+++ b/scm/deployment_services/docs/BandwidthAllocationsQos.md
@@ -0,0 +1,32 @@
+# BandwidthAllocationsQos
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**customized** | **bool** | | [optional] [default to False]
+**enabled** | **bool** | | [optional] [default to False]
+**guaranteed_ratio** | **float** | | [optional] [default to 0]
+**profile** | **str** | | [optional] [default to '']
+
+## Example
+
+```python
+from scm.deployment_services.models.bandwidth_allocations_qos import BandwidthAllocationsQos
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of BandwidthAllocationsQos from a JSON string
+bandwidth_allocations_qos_instance = BandwidthAllocationsQos.from_json(json)
+# print the JSON string representation of the object
+print(BandwidthAllocationsQos.to_json())
+
+# convert the object into a dict
+bandwidth_allocations_qos_dict = bandwidth_allocations_qos_instance.to_dict()
+# create an instance of BandwidthAllocationsQos from a dict
+bandwidth_allocations_qos_from_dict = BandwidthAllocationsQos.from_dict(bandwidth_allocations_qos_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/BgpRouting.md b/scm/deployment_services/docs/BgpRouting.md
new file mode 100644
index 00000000..1881c767
--- /dev/null
+++ b/scm/deployment_services/docs/BgpRouting.md
@@ -0,0 +1,34 @@
+# BgpRouting
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**accept_route_over_sc** | **bool** | | [optional]
+**add_host_route_to_ike_peer** | **bool** | | [optional]
+**backbone_routing** | **str** | | [optional]
+**outbound_routes_for_services** | **List[str]** | | [optional]
+**routing_preference** | [**BgpRoutingRoutingPreference**](BgpRoutingRoutingPreference.md) | | [optional]
+**withdraw_static_route** | **bool** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.bgp_routing import BgpRouting
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of BgpRouting from a JSON string
+bgp_routing_instance = BgpRouting.from_json(json)
+# print the JSON string representation of the object
+print(BgpRouting.to_json())
+
+# convert the object into a dict
+bgp_routing_dict = bgp_routing_instance.to_dict()
+# create an instance of BgpRouting from a dict
+bgp_routing_from_dict = BgpRouting.from_dict(bgp_routing_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/BgpRoutingRoutingPreference.md b/scm/deployment_services/docs/BgpRoutingRoutingPreference.md
new file mode 100644
index 00000000..a32e3a8e
--- /dev/null
+++ b/scm/deployment_services/docs/BgpRoutingRoutingPreference.md
@@ -0,0 +1,30 @@
+# BgpRoutingRoutingPreference
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**default** | **object** | | [optional]
+**hot_potato_routing** | **object** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.bgp_routing_routing_preference import BgpRoutingRoutingPreference
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of BgpRoutingRoutingPreference from a JSON string
+bgp_routing_routing_preference_instance = BgpRoutingRoutingPreference.from_json(json)
+# print the JSON string representation of the object
+print(BgpRoutingRoutingPreference.to_json())
+
+# convert the object into a dict
+bgp_routing_routing_preference_dict = bgp_routing_routing_preference_instance.to_dict()
+# create an instance of BgpRoutingRoutingPreference from a dict
+bgp_routing_routing_preference_from_dict = BgpRoutingRoutingPreference.from_dict(bgp_routing_routing_preference_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/EditSharedInfrastructureSettings.md b/scm/deployment_services/docs/EditSharedInfrastructureSettings.md
new file mode 100644
index 00000000..6134b98e
--- /dev/null
+++ b/scm/deployment_services/docs/EditSharedInfrastructureSettings.md
@@ -0,0 +1,34 @@
+# EditSharedInfrastructureSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**connector_application_blocks** | [**EditSharedInfrastructureSettingsConnectorApplicationBlocks**](EditSharedInfrastructureSettingsConnectorApplicationBlocks.md) | | [optional]
+**connector_connector_blocks** | [**EditSharedInfrastructureSettingsConnectorConnectorBlocks**](EditSharedInfrastructureSettingsConnectorConnectorBlocks.md) | | [optional]
+**egress_ip_notification_url** | **str** | | [optional]
+**infra_bgp_as** | **str** | | [optional]
+**infrastructure_subnet** | **str** | | [optional]
+**infrastructure_subnet_ipv6** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.edit_shared_infrastructure_settings import EditSharedInfrastructureSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of EditSharedInfrastructureSettings from a JSON string
+edit_shared_infrastructure_settings_instance = EditSharedInfrastructureSettings.from_json(json)
+# print the JSON string representation of the object
+print(EditSharedInfrastructureSettings.to_json())
+
+# convert the object into a dict
+edit_shared_infrastructure_settings_dict = edit_shared_infrastructure_settings_instance.to_dict()
+# create an instance of EditSharedInfrastructureSettings from a dict
+edit_shared_infrastructure_settings_from_dict = EditSharedInfrastructureSettings.from_dict(edit_shared_infrastructure_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/EditSharedInfrastructureSettingsConnectorApplicationBlocks.md b/scm/deployment_services/docs/EditSharedInfrastructureSettingsConnectorApplicationBlocks.md
new file mode 100644
index 00000000..3c2f96df
--- /dev/null
+++ b/scm/deployment_services/docs/EditSharedInfrastructureSettingsConnectorApplicationBlocks.md
@@ -0,0 +1,29 @@
+# EditSharedInfrastructureSettingsConnectorApplicationBlocks
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**member** | **List[str]** | Array of CIDR blocks for connector-to-application communication | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_application_blocks import EditSharedInfrastructureSettingsConnectorApplicationBlocks
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of EditSharedInfrastructureSettingsConnectorApplicationBlocks from a JSON string
+edit_shared_infrastructure_settings_connector_application_blocks_instance = EditSharedInfrastructureSettingsConnectorApplicationBlocks.from_json(json)
+# print the JSON string representation of the object
+print(EditSharedInfrastructureSettingsConnectorApplicationBlocks.to_json())
+
+# convert the object into a dict
+edit_shared_infrastructure_settings_connector_application_blocks_dict = edit_shared_infrastructure_settings_connector_application_blocks_instance.to_dict()
+# create an instance of EditSharedInfrastructureSettingsConnectorApplicationBlocks from a dict
+edit_shared_infrastructure_settings_connector_application_blocks_from_dict = EditSharedInfrastructureSettingsConnectorApplicationBlocks.from_dict(edit_shared_infrastructure_settings_connector_application_blocks_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/EditSharedInfrastructureSettingsConnectorConnectorBlocks.md b/scm/deployment_services/docs/EditSharedInfrastructureSettingsConnectorConnectorBlocks.md
new file mode 100644
index 00000000..0b054ebb
--- /dev/null
+++ b/scm/deployment_services/docs/EditSharedInfrastructureSettingsConnectorConnectorBlocks.md
@@ -0,0 +1,29 @@
+# EditSharedInfrastructureSettingsConnectorConnectorBlocks
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**member** | **List[str]** | Array of CIDR blocks for connector-to-connector communication | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_connector_blocks import EditSharedInfrastructureSettingsConnectorConnectorBlocks
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of EditSharedInfrastructureSettingsConnectorConnectorBlocks from a JSON string
+edit_shared_infrastructure_settings_connector_connector_blocks_instance = EditSharedInfrastructureSettingsConnectorConnectorBlocks.from_json(json)
+# print the JSON string representation of the object
+print(EditSharedInfrastructureSettingsConnectorConnectorBlocks.to_json())
+
+# convert the object into a dict
+edit_shared_infrastructure_settings_connector_connector_blocks_dict = edit_shared_infrastructure_settings_connector_connector_blocks_instance.to_dict()
+# create an instance of EditSharedInfrastructureSettingsConnectorConnectorBlocks from a dict
+edit_shared_infrastructure_settings_connector_connector_blocks_from_dict = EditSharedInfrastructureSettingsConnectorConnectorBlocks.from_dict(edit_shared_infrastructure_settings_connector_connector_blocks_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ErrorDetailCauseInfo.md b/scm/deployment_services/docs/ErrorDetailCauseInfo.md
new file mode 100644
index 00000000..8aa1f9f4
--- /dev/null
+++ b/scm/deployment_services/docs/ErrorDetailCauseInfo.md
@@ -0,0 +1,32 @@
+# ErrorDetailCauseInfo
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **str** | | [optional]
+**details** | **object** | | [optional]
+**help** | **str** | | [optional]
+**message** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ErrorDetailCauseInfo from a JSON string
+error_detail_cause_info_instance = ErrorDetailCauseInfo.from_json(json)
+# print the JSON string representation of the object
+print(ErrorDetailCauseInfo.to_json())
+
+# convert the object into a dict
+error_detail_cause_info_dict = error_detail_cause_info_instance.to_dict()
+# create an instance of ErrorDetailCauseInfo from a dict
+error_detail_cause_info_from_dict = ErrorDetailCauseInfo.from_dict(error_detail_cause_info_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/GenericError.md b/scm/deployment_services/docs/GenericError.md
new file mode 100644
index 00000000..93041e5f
--- /dev/null
+++ b/scm/deployment_services/docs/GenericError.md
@@ -0,0 +1,30 @@
+# GenericError
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**errors** | [**List[ErrorDetailCauseInfo]**](ErrorDetailCauseInfo.md) | | [optional]
+**request_id** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.generic_error import GenericError
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GenericError from a JSON string
+generic_error_instance = GenericError.from_json(json)
+# print the JSON string representation of the object
+print(GenericError.to_json())
+
+# convert the object into a dict
+generic_error_dict = generic_error_instance.to_dict()
+# create an instance of GenericError from a dict
+generic_error_from_dict = GenericError.from_dict(generic_error_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/InternalDNSServersApi.md b/scm/deployment_services/docs/InternalDNSServersApi.md
new file mode 100644
index 00000000..3fec7d14
--- /dev/null
+++ b/scm/deployment_services/docs/InternalDNSServersApi.md
@@ -0,0 +1,433 @@
+# scm.deployment_services.InternalDNSServersApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_internal_dns_servers**](InternalDNSServersApi.md#create_internal_dns_servers) | **POST** /internal-dns-servers | Create a internal DNS server
+[**delete_internal_dns_servers_by_id**](InternalDNSServersApi.md#delete_internal_dns_servers_by_id) | **DELETE** /internal-dns-servers/{id} | Delete an internal DNS server
+[**get_internal_dns_servers_by_id**](InternalDNSServersApi.md#get_internal_dns_servers_by_id) | **GET** /internal-dns-servers/{id} | Get an internal DNS server
+[**list_internal_dns_servers**](InternalDNSServersApi.md#list_internal_dns_servers) | **GET** /internal-dns-servers | List internal DNS servers
+[**update_internal_dns_servers_by_id**](InternalDNSServersApi.md#update_internal_dns_servers_by_id) | **PUT** /internal-dns-servers/{id} | Update an internal DNS server
+
+
+# **create_internal_dns_servers**
+> InternalDnsServers create_internal_dns_servers(internal_dns_servers=internal_dns_servers)
+
+Create a internal DNS server
+
+Create a new internal DNS server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.InternalDNSServersApi(api_client)
+ internal_dns_servers = scm.deployment_services.InternalDnsServers() # InternalDnsServers | Created (optional)
+
+ try:
+ # Create a internal DNS server
+ api_response = api_instance.create_internal_dns_servers(internal_dns_servers=internal_dns_servers)
+ print("The response of InternalDNSServersApi->create_internal_dns_servers:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling InternalDNSServersApi->create_internal_dns_servers: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **internal_dns_servers** | [**InternalDnsServers**](InternalDnsServers.md)| Created | [optional]
+
+### Return type
+
+[**InternalDnsServers**](InternalDnsServers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_internal_dns_servers_by_id**
+> delete_internal_dns_servers_by_id(id)
+
+Delete an internal DNS server
+
+Delete an internal DNS server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.InternalDNSServersApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an internal DNS server
+ api_instance.delete_internal_dns_servers_by_id(id)
+ except Exception as e:
+ print("Exception when calling InternalDNSServersApi->delete_internal_dns_servers_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_internal_dns_servers_by_id**
+> InternalDnsServers get_internal_dns_servers_by_id(id)
+
+Get an internal DNS server
+
+Get an existing internal DNS server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.InternalDNSServersApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Get an internal DNS server
+ api_response = api_instance.get_internal_dns_servers_by_id(id)
+ print("The response of InternalDNSServersApi->get_internal_dns_servers_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling InternalDNSServersApi->get_internal_dns_servers_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**InternalDnsServers**](InternalDnsServers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_internal_dns_servers**
+> InternalDNSServersListResponse list_internal_dns_servers(limit=limit, offset=offset, name=name)
+
+List internal DNS servers
+
+Retrieve a list of internal DNS servers.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.internal_dns_servers_list_response import InternalDNSServersListResponse
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.InternalDNSServersApi(api_client)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+
+ try:
+ # List internal DNS servers
+ api_response = api_instance.list_internal_dns_servers(limit=limit, offset=offset, name=name)
+ print("The response of InternalDNSServersApi->list_internal_dns_servers:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling InternalDNSServersApi->list_internal_dns_servers: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+ **name** | **str**| The name of the configuration resource | [optional]
+
+### Return type
+
+[**InternalDNSServersListResponse**](InternalDNSServersListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_internal_dns_servers_by_id**
+> InternalDnsServers update_internal_dns_servers_by_id(id, internal_dns_servers=internal_dns_servers)
+
+Update an internal DNS server
+
+Update an existing internal dns server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.InternalDNSServersApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+ internal_dns_servers = scm.deployment_services.InternalDnsServers() # InternalDnsServers | OK (optional)
+
+ try:
+ # Update an internal DNS server
+ api_response = api_instance.update_internal_dns_servers_by_id(id, internal_dns_servers=internal_dns_servers)
+ print("The response of InternalDNSServersApi->update_internal_dns_servers_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling InternalDNSServersApi->update_internal_dns_servers_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **internal_dns_servers** | [**InternalDnsServers**](InternalDnsServers.md)| OK | [optional]
+
+### Return type
+
+[**InternalDnsServers**](InternalDnsServers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/InternalDNSServersListResponse.md b/scm/deployment_services/docs/InternalDNSServersListResponse.md
new file mode 100644
index 00000000..9913e507
--- /dev/null
+++ b/scm/deployment_services/docs/InternalDNSServersListResponse.md
@@ -0,0 +1,32 @@
+# InternalDNSServersListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[InternalDnsServers]**](InternalDnsServers.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.deployment_services.models.internal_dns_servers_list_response import InternalDNSServersListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of InternalDNSServersListResponse from a JSON string
+internal_dns_servers_list_response_instance = InternalDNSServersListResponse.from_json(json)
+# print the JSON string representation of the object
+print(InternalDNSServersListResponse.to_json())
+
+# convert the object into a dict
+internal_dns_servers_list_response_dict = internal_dns_servers_list_response_instance.to_dict()
+# create an instance of InternalDNSServersListResponse from a dict
+internal_dns_servers_list_response_from_dict = InternalDNSServersListResponse.from_dict(internal_dns_servers_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/InternalDnsServers.md b/scm/deployment_services/docs/InternalDnsServers.md
new file mode 100644
index 00000000..4b617fc2
--- /dev/null
+++ b/scm/deployment_services/docs/InternalDnsServers.md
@@ -0,0 +1,33 @@
+# InternalDnsServers
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**domain_name** | **List[str]** | The DNS domain name(s) |
+**id** | **str** | The UUID of the internet DNS server resource | [readonly]
+**name** | **str** | The name of the internet DNS server resource |
+**primary** | **str** | The IP address of the primary DNS server |
+**secondary** | **str** | The IP address of the secondary DNS server | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of InternalDnsServers from a JSON string
+internal_dns_servers_instance = InternalDnsServers.from_json(json)
+# print the JSON string representation of the object
+print(InternalDnsServers.to_json())
+
+# convert the object into a dict
+internal_dns_servers_dict = internal_dns_servers_instance.to_dict()
+# create an instance of InternalDnsServers from a dict
+internal_dns_servers_from_dict = InternalDnsServers.from_dict(internal_dns_servers_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/Locations.md b/scm/deployment_services/docs/Locations.md
new file mode 100644
index 00000000..2d21fb50
--- /dev/null
+++ b/scm/deployment_services/docs/Locations.md
@@ -0,0 +1,35 @@
+# Locations
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**aggregate_region** | **str** | | [optional]
+**continent** | **str** | The continent in which the location exists | [optional]
+**display** | **str** | The location as displayed in the Strata Cloud Manager portal | [optional]
+**latitude** | **float** | The latitudinal position of the location | [optional]
+**longitude** | **float** | The longitudinal position of the location | [optional]
+**region** | **str** | | [optional]
+**value** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.locations import Locations
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Locations from a JSON string
+locations_instance = Locations.from_json(json)
+# print the JSON string representation of the object
+print(Locations.to_json())
+
+# convert the object into a dict
+locations_dict = locations_instance.to_dict()
+# create an instance of Locations from a dict
+locations_from_dict = Locations.from_dict(locations_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/NetworkLocationsApi.md b/scm/deployment_services/docs/NetworkLocationsApi.md
new file mode 100644
index 00000000..6ccd2fd4
--- /dev/null
+++ b/scm/deployment_services/docs/NetworkLocationsApi.md
@@ -0,0 +1,89 @@
+# scm.deployment_services.NetworkLocationsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**list_locations**](NetworkLocationsApi.md#list_locations) | **GET** /locations | List locations
+
+
+# **list_locations**
+> List[Locations] list_locations()
+
+List locations
+
+Retrieve a list of Prisma Access locations.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.locations import Locations
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.NetworkLocationsApi(api_client)
+
+ try:
+ # List locations
+ api_response = api_instance.list_locations()
+ print("The response of NetworkLocationsApi->list_locations:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling NetworkLocationsApi->list_locations: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**List[Locations]**](Locations.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/RemoteNetworks.md b/scm/deployment_services/docs/RemoteNetworks.md
new file mode 100644
index 00000000..f07d5c36
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworks.md
@@ -0,0 +1,40 @@
+# RemoteNetworks
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ecmp_load_balancing** | **str** | | [optional] [default to 'disable']
+**ecmp_tunnels** | [**List[RemoteNetworksEcmpTunnelsInner]**](RemoteNetworksEcmpTunnelsInner.md) | ecmp_tunnels is required when ecmp_load_balancing is enable | [optional]
+**folder** | **str** | The folder that contains the remote network | [default to 'Remote Networks']
+**id** | **str** | The UUID of the remote network | [readonly]
+**ipsec_tunnel** | **str** | ipsec_tunnel is required when ecmp_load_balancing is disable | [optional]
+**license_type** | **str** | New customer will only be on aggregate bandwidth licensing | [default to 'FWAAS-AGGREGATE']
+**name** | **str** | The name of the remote network |
+**protocol** | [**RemoteNetworksProtocol**](RemoteNetworksProtocol.md) | | [optional]
+**region** | **str** | |
+**secondary_ipsec_tunnel** | **str** | specify secondary ipsec_tunnel if needed | [optional]
+**spn_name** | **str** | spn-name is needed when license_type is FWAAS-AGGREGATE | [optional]
+**subnets** | **List[str]** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RemoteNetworks from a JSON string
+remote_networks_instance = RemoteNetworks.from_json(json)
+# print the JSON string representation of the object
+print(RemoteNetworks.to_json())
+
+# convert the object into a dict
+remote_networks_dict = remote_networks_instance.to_dict()
+# create an instance of RemoteNetworks from a dict
+remote_networks_from_dict = RemoteNetworks.from_dict(remote_networks_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/RemoteNetworksApi.md b/scm/deployment_services/docs/RemoteNetworksApi.md
new file mode 100644
index 00000000..3156a527
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworksApi.md
@@ -0,0 +1,435 @@
+# scm.deployment_services.RemoteNetworksApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_remote_networks**](RemoteNetworksApi.md#create_remote_networks) | **POST** /remote-networks | Create a remote network
+[**delete_remote_networks_by_id**](RemoteNetworksApi.md#delete_remote_networks_by_id) | **DELETE** /remote-networks/{id} | Delete a remote network
+[**get_remote_networks_by_id**](RemoteNetworksApi.md#get_remote_networks_by_id) | **GET** /remote-networks/{id} | Get a remote network
+[**list_remote_networks**](RemoteNetworksApi.md#list_remote_networks) | **GET** /remote-networks | List remote networks
+[**update_remote_networks_by_id**](RemoteNetworksApi.md#update_remote_networks_by_id) | **PUT** /remote-networks/{id} | Update a remote network
+
+
+# **create_remote_networks**
+> RemoteNetworks create_remote_networks(remote_networks=remote_networks)
+
+Create a remote network
+
+Create a new remote network.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.RemoteNetworksApi(api_client)
+ remote_networks = scm.deployment_services.RemoteNetworks() # RemoteNetworks | Created (optional)
+
+ try:
+ # Create a remote network
+ api_response = api_instance.create_remote_networks(remote_networks=remote_networks)
+ print("The response of RemoteNetworksApi->create_remote_networks:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RemoteNetworksApi->create_remote_networks: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **remote_networks** | [**RemoteNetworks**](RemoteNetworks.md)| Created | [optional]
+
+### Return type
+
+[**RemoteNetworks**](RemoteNetworks.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_remote_networks_by_id**
+> delete_remote_networks_by_id(id)
+
+Delete a remote network
+
+Delete a remote network.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.RemoteNetworksApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a remote network
+ api_instance.delete_remote_networks_by_id(id)
+ except Exception as e:
+ print("Exception when calling RemoteNetworksApi->delete_remote_networks_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_remote_networks_by_id**
+> RemoteNetworks get_remote_networks_by_id(id)
+
+Get a remote network
+
+Get an existing remote network.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.RemoteNetworksApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Get a remote network
+ api_response = api_instance.get_remote_networks_by_id(id)
+ print("The response of RemoteNetworksApi->get_remote_networks_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RemoteNetworksApi->get_remote_networks_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**RemoteNetworks**](RemoteNetworks.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_remote_networks**
+> RemoteNetworksListResponse list_remote_networks(folder, limit=limit, offset=offset, name=name)
+
+List remote networks
+
+Retrieve a list of remote networks.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.remote_networks_list_response import RemoteNetworksListResponse
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.RemoteNetworksApi(api_client)
+ folder = Remote Networks # str | The folder in which the resource is defined (default to Remote Networks)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+
+ try:
+ # List remote networks
+ api_response = api_instance.list_remote_networks(folder, limit=limit, offset=offset, name=name)
+ print("The response of RemoteNetworksApi->list_remote_networks:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RemoteNetworksApi->list_remote_networks: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [default to Remote Networks]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+ **name** | **str**| The name of the configuration resource | [optional]
+
+### Return type
+
+[**RemoteNetworksListResponse**](RemoteNetworksListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_remote_networks_by_id**
+> RemoteNetworks update_remote_networks_by_id(id, remote_networks=remote_networks)
+
+Update a remote network
+
+Update an existing remote network.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.RemoteNetworksApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+ remote_networks = scm.deployment_services.RemoteNetworks() # RemoteNetworks | OK (optional)
+
+ try:
+ # Update a remote network
+ api_response = api_instance.update_remote_networks_by_id(id, remote_networks=remote_networks)
+ print("The response of RemoteNetworksApi->update_remote_networks_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RemoteNetworksApi->update_remote_networks_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **remote_networks** | [**RemoteNetworks**](RemoteNetworks.md)| OK | [optional]
+
+### Return type
+
+[**RemoteNetworks**](RemoteNetworks.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/RemoteNetworksEcmpTunnelsInner.md b/scm/deployment_services/docs/RemoteNetworksEcmpTunnelsInner.md
new file mode 100644
index 00000000..9ed321b6
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworksEcmpTunnelsInner.md
@@ -0,0 +1,31 @@
+# RemoteNetworksEcmpTunnelsInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ipsec_tunnel** | **str** | |
+**name** | **str** | |
+**protocol** | [**RemoteNetworksEcmpTunnelsInnerProtocol**](RemoteNetworksEcmpTunnelsInnerProtocol.md) | |
+
+## Example
+
+```python
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner import RemoteNetworksEcmpTunnelsInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RemoteNetworksEcmpTunnelsInner from a JSON string
+remote_networks_ecmp_tunnels_inner_instance = RemoteNetworksEcmpTunnelsInner.from_json(json)
+# print the JSON string representation of the object
+print(RemoteNetworksEcmpTunnelsInner.to_json())
+
+# convert the object into a dict
+remote_networks_ecmp_tunnels_inner_dict = remote_networks_ecmp_tunnels_inner_instance.to_dict()
+# create an instance of RemoteNetworksEcmpTunnelsInner from a dict
+remote_networks_ecmp_tunnels_inner_from_dict = RemoteNetworksEcmpTunnelsInner.from_dict(remote_networks_ecmp_tunnels_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/RemoteNetworksEcmpTunnelsInnerProtocol.md b/scm/deployment_services/docs/RemoteNetworksEcmpTunnelsInnerProtocol.md
new file mode 100644
index 00000000..0babc760
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworksEcmpTunnelsInnerProtocol.md
@@ -0,0 +1,29 @@
+# RemoteNetworksEcmpTunnelsInnerProtocol
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bgp** | [**RemoteNetworksProtocolBgp**](RemoteNetworksProtocolBgp.md) | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner_protocol import RemoteNetworksEcmpTunnelsInnerProtocol
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RemoteNetworksEcmpTunnelsInnerProtocol from a JSON string
+remote_networks_ecmp_tunnels_inner_protocol_instance = RemoteNetworksEcmpTunnelsInnerProtocol.from_json(json)
+# print the JSON string representation of the object
+print(RemoteNetworksEcmpTunnelsInnerProtocol.to_json())
+
+# convert the object into a dict
+remote_networks_ecmp_tunnels_inner_protocol_dict = remote_networks_ecmp_tunnels_inner_protocol_instance.to_dict()
+# create an instance of RemoteNetworksEcmpTunnelsInnerProtocol from a dict
+remote_networks_ecmp_tunnels_inner_protocol_from_dict = RemoteNetworksEcmpTunnelsInnerProtocol.from_dict(remote_networks_ecmp_tunnels_inner_protocol_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/RemoteNetworksListResponse.md b/scm/deployment_services/docs/RemoteNetworksListResponse.md
new file mode 100644
index 00000000..a2dc40ac
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworksListResponse.md
@@ -0,0 +1,32 @@
+# RemoteNetworksListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[RemoteNetworks]**](RemoteNetworks.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.deployment_services.models.remote_networks_list_response import RemoteNetworksListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RemoteNetworksListResponse from a JSON string
+remote_networks_list_response_instance = RemoteNetworksListResponse.from_json(json)
+# print the JSON string representation of the object
+print(RemoteNetworksListResponse.to_json())
+
+# convert the object into a dict
+remote_networks_list_response_dict = remote_networks_list_response_instance.to_dict()
+# create an instance of RemoteNetworksListResponse from a dict
+remote_networks_list_response_from_dict = RemoteNetworksListResponse.from_dict(remote_networks_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/RemoteNetworksProtocol.md b/scm/deployment_services/docs/RemoteNetworksProtocol.md
new file mode 100644
index 00000000..b3baab77
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworksProtocol.md
@@ -0,0 +1,31 @@
+# RemoteNetworksProtocol
+
+setup the protocol when ecmp_load_balancing is disable
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bgp** | [**RemoteNetworksProtocolBgp**](RemoteNetworksProtocolBgp.md) | | [optional]
+**bgp_peer** | [**RemoteNetworksProtocolBgpPeer**](RemoteNetworksProtocolBgpPeer.md) | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.remote_networks_protocol import RemoteNetworksProtocol
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RemoteNetworksProtocol from a JSON string
+remote_networks_protocol_instance = RemoteNetworksProtocol.from_json(json)
+# print the JSON string representation of the object
+print(RemoteNetworksProtocol.to_json())
+
+# convert the object into a dict
+remote_networks_protocol_dict = remote_networks_protocol_instance.to_dict()
+# create an instance of RemoteNetworksProtocol from a dict
+remote_networks_protocol_from_dict = RemoteNetworksProtocol.from_dict(remote_networks_protocol_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/RemoteNetworksProtocolBgp.md b/scm/deployment_services/docs/RemoteNetworksProtocolBgp.md
new file mode 100644
index 00000000..4b8525b4
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworksProtocolBgp.md
@@ -0,0 +1,37 @@
+# RemoteNetworksProtocolBgp
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**do_not_export_routes** | **bool** | Do not export routes? | [optional]
+**enable** | **bool** | Enable BGP peering? | [optional]
+**local_ip_address** | **str** | Local peer IP address | [optional]
+**originate_default_route** | **bool** | Originate default route? | [optional]
+**peer_as** | **str** | BGP peer ASN | [optional]
+**peer_ip_address** | **str** | Remote peer IP address | [optional]
+**peering_type** | **str** | Route exchange types | [optional]
+**secret** | **str** | BGP peering secret | [optional]
+**summarize_mobile_user_routes** | **bool** | Summarize mobile user routes? | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.remote_networks_protocol_bgp import RemoteNetworksProtocolBgp
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RemoteNetworksProtocolBgp from a JSON string
+remote_networks_protocol_bgp_instance = RemoteNetworksProtocolBgp.from_json(json)
+# print the JSON string representation of the object
+print(RemoteNetworksProtocolBgp.to_json())
+
+# convert the object into a dict
+remote_networks_protocol_bgp_dict = remote_networks_protocol_bgp_instance.to_dict()
+# create an instance of RemoteNetworksProtocolBgp from a dict
+remote_networks_protocol_bgp_from_dict = RemoteNetworksProtocolBgp.from_dict(remote_networks_protocol_bgp_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/RemoteNetworksProtocolBgpPeer.md b/scm/deployment_services/docs/RemoteNetworksProtocolBgpPeer.md
new file mode 100644
index 00000000..39e7bb24
--- /dev/null
+++ b/scm/deployment_services/docs/RemoteNetworksProtocolBgpPeer.md
@@ -0,0 +1,33 @@
+# RemoteNetworksProtocolBgpPeer
+
+secondary bgp routing as bgp_peer
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**local_ip_address** | **str** | Local peer IP address (secondary WAN) | [optional]
+**peer_ip_address** | **str** | Remote peer IP address (secondary WAN) | [optional]
+**same_as_primary** | **bool** | Same peer IP address as primary WAN | [optional]
+**secret** | **str** | BGP peering secret (secondary WAN) | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.remote_networks_protocol_bgp_peer import RemoteNetworksProtocolBgpPeer
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RemoteNetworksProtocolBgpPeer from a JSON string
+remote_networks_protocol_bgp_peer_instance = RemoteNetworksProtocolBgpPeer.from_json(json)
+# print the JSON string representation of the object
+print(RemoteNetworksProtocolBgpPeer.to_json())
+
+# convert the object into a dict
+remote_networks_protocol_bgp_peer_dict = remote_networks_protocol_bgp_peer_instance.to_dict()
+# create an instance of RemoteNetworksProtocolBgpPeer from a dict
+remote_networks_protocol_bgp_peer_from_dict = RemoteNetworksProtocolBgpPeer.from_dict(remote_networks_protocol_bgp_peer_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnectionGroups.md b/scm/deployment_services/docs/ServiceConnectionGroups.md
new file mode 100644
index 00000000..21e92400
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionGroups.md
@@ -0,0 +1,33 @@
+# ServiceConnectionGroups
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**disable_snat** | **bool** | | [optional]
+**id** | **str** | The UUID of the service connection group | [readonly]
+**name** | **str** | |
+**pbf_only** | **bool** | | [optional]
+**target** | **List[str]** | |
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnectionGroups from a JSON string
+service_connection_groups_instance = ServiceConnectionGroups.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnectionGroups.to_json())
+
+# convert the object into a dict
+service_connection_groups_dict = service_connection_groups_instance.to_dict()
+# create an instance of ServiceConnectionGroups from a dict
+service_connection_groups_from_dict = ServiceConnectionGroups.from_dict(service_connection_groups_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnectionGroupsApi.md b/scm/deployment_services/docs/ServiceConnectionGroupsApi.md
new file mode 100644
index 00000000..61dcf993
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionGroupsApi.md
@@ -0,0 +1,435 @@
+# scm.deployment_services.ServiceConnectionGroupsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_service_connection_groups**](ServiceConnectionGroupsApi.md#create_service_connection_groups) | **POST** /service-connection-groups | Create a service connection group
+[**delete_service_connection_groups_by_id**](ServiceConnectionGroupsApi.md#delete_service_connection_groups_by_id) | **DELETE** /service-connection-groups/{id} | Delete a service connection group
+[**get_service_connection_groups_by_id**](ServiceConnectionGroupsApi.md#get_service_connection_groups_by_id) | **GET** /service-connection-groups/{id} | Get a service connection group
+[**list_service_connection_groups**](ServiceConnectionGroupsApi.md#list_service_connection_groups) | **GET** /service-connection-groups | List service connection groups
+[**update_service_connection_groups_by_id**](ServiceConnectionGroupsApi.md#update_service_connection_groups_by_id) | **PUT** /service-connection-groups/{id} | Update a service connection group
+
+
+# **create_service_connection_groups**
+> ServiceConnectionGroups create_service_connection_groups(service_connection_groups=service_connection_groups)
+
+Create a service connection group
+
+Create a new service connection group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionGroupsApi(api_client)
+ service_connection_groups = scm.deployment_services.ServiceConnectionGroups() # ServiceConnectionGroups | Created (optional)
+
+ try:
+ # Create a service connection group
+ api_response = api_instance.create_service_connection_groups(service_connection_groups=service_connection_groups)
+ print("The response of ServiceConnectionGroupsApi->create_service_connection_groups:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionGroupsApi->create_service_connection_groups: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **service_connection_groups** | [**ServiceConnectionGroups**](ServiceConnectionGroups.md)| Created | [optional]
+
+### Return type
+
+[**ServiceConnectionGroups**](ServiceConnectionGroups.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_service_connection_groups_by_id**
+> delete_service_connection_groups_by_id(id)
+
+Delete a service connection group
+
+Delete a service connection group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionGroupsApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a service connection group
+ api_instance.delete_service_connection_groups_by_id(id)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionGroupsApi->delete_service_connection_groups_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_service_connection_groups_by_id**
+> ServiceConnectionGroups get_service_connection_groups_by_id(id)
+
+Get a service connection group
+
+Get an existing service connection group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionGroupsApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Get a service connection group
+ api_response = api_instance.get_service_connection_groups_by_id(id)
+ print("The response of ServiceConnectionGroupsApi->get_service_connection_groups_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionGroupsApi->get_service_connection_groups_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**ServiceConnectionGroups**](ServiceConnectionGroups.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_service_connection_groups**
+> ServiceConnectionGroupsListResponse list_service_connection_groups(folder, limit=limit, offset=offset, name=name)
+
+List service connection groups
+
+Retrieve a list of service connection groups.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connection_groups_list_response import ServiceConnectionGroupsListResponse
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionGroupsApi(api_client)
+ folder = Service Connections # str | The folder in which the resource is defined (default to Service Connections)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+
+ try:
+ # List service connection groups
+ api_response = api_instance.list_service_connection_groups(folder, limit=limit, offset=offset, name=name)
+ print("The response of ServiceConnectionGroupsApi->list_service_connection_groups:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionGroupsApi->list_service_connection_groups: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [default to Service Connections]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+ **name** | **str**| The name of the configuration resource | [optional]
+
+### Return type
+
+[**ServiceConnectionGroupsListResponse**](ServiceConnectionGroupsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_service_connection_groups_by_id**
+> ServiceConnectionGroups update_service_connection_groups_by_id(id, service_connection_groups=service_connection_groups)
+
+Update a service connection group
+
+Update an existing service connection group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionGroupsApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+ service_connection_groups = scm.deployment_services.ServiceConnectionGroups() # ServiceConnectionGroups | OK (optional)
+
+ try:
+ # Update a service connection group
+ api_response = api_instance.update_service_connection_groups_by_id(id, service_connection_groups=service_connection_groups)
+ print("The response of ServiceConnectionGroupsApi->update_service_connection_groups_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionGroupsApi->update_service_connection_groups_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **service_connection_groups** | [**ServiceConnectionGroups**](ServiceConnectionGroups.md)| OK | [optional]
+
+### Return type
+
+[**ServiceConnectionGroups**](ServiceConnectionGroups.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/ServiceConnectionGroupsListResponse.md b/scm/deployment_services/docs/ServiceConnectionGroupsListResponse.md
new file mode 100644
index 00000000..d11f7956
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionGroupsListResponse.md
@@ -0,0 +1,32 @@
+# ServiceConnectionGroupsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[ServiceConnectionGroups]**](ServiceConnectionGroups.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connection_groups_list_response import ServiceConnectionGroupsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnectionGroupsListResponse from a JSON string
+service_connection_groups_list_response_instance = ServiceConnectionGroupsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnectionGroupsListResponse.to_json())
+
+# convert the object into a dict
+service_connection_groups_list_response_dict = service_connection_groups_list_response_instance.to_dict()
+# create an instance of ServiceConnectionGroupsListResponse from a dict
+service_connection_groups_list_response_from_dict = ServiceConnectionGroupsListResponse.from_dict(service_connection_groups_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnections.md b/scm/deployment_services/docs/ServiceConnections.md
new file mode 100644
index 00000000..ae581fe6
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnections.md
@@ -0,0 +1,42 @@
+# ServiceConnections
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**backup_sc** | **str** | | [optional]
+**bgp_peer** | [**ServiceConnectionsBgpPeer**](ServiceConnectionsBgpPeer.md) | | [optional]
+**id** | **str** | The UUID of the service connection | [readonly]
+**ipsec_tunnel** | **str** | |
+**name** | **str** | The name of the service connection |
+**nat_pool** | **str** | | [optional]
+**no_export_community** | **str** | | [optional]
+**onboarding_type** | **str** | | [optional] [default to 'classic']
+**protocol** | [**ServiceConnectionsProtocol**](ServiceConnectionsProtocol.md) | | [optional]
+**qos** | [**ServiceConnectionsQos**](ServiceConnectionsQos.md) | | [optional]
+**region** | **str** | |
+**secondary_ipsec_tunnel** | **str** | | [optional]
+**source_nat** | **bool** | | [optional]
+**subnets** | **List[str]** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connections import ServiceConnections
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnections from a JSON string
+service_connections_instance = ServiceConnections.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnections.to_json())
+
+# convert the object into a dict
+service_connections_dict = service_connections_instance.to_dict()
+# create an instance of ServiceConnections from a dict
+service_connections_from_dict = ServiceConnections.from_dict(service_connections_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnectionsApi.md b/scm/deployment_services/docs/ServiceConnectionsApi.md
new file mode 100644
index 00000000..9cd34b0a
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionsApi.md
@@ -0,0 +1,435 @@
+# scm.deployment_services.ServiceConnectionsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_service_connections**](ServiceConnectionsApi.md#create_service_connections) | **POST** /service-connections | Create a service connection
+[**delete_service_connections_by_id**](ServiceConnectionsApi.md#delete_service_connections_by_id) | **DELETE** /service-connections/{id} | Delete a service connection
+[**get_service_connections_by_id**](ServiceConnectionsApi.md#get_service_connections_by_id) | **GET** /service-connections/{id} | Get a service connection
+[**list_service_connections**](ServiceConnectionsApi.md#list_service_connections) | **GET** /service-connections | List service connections
+[**update_service_connections_by_id**](ServiceConnectionsApi.md#update_service_connections_by_id) | **PUT** /service-connections/{id} | Update a service connection
+
+
+# **create_service_connections**
+> ServiceConnections create_service_connections(service_connections=service_connections)
+
+Create a service connection
+
+Create a new service connection.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionsApi(api_client)
+ service_connections = scm.deployment_services.ServiceConnections() # ServiceConnections | Created (optional)
+
+ try:
+ # Create a service connection
+ api_response = api_instance.create_service_connections(service_connections=service_connections)
+ print("The response of ServiceConnectionsApi->create_service_connections:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionsApi->create_service_connections: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **service_connections** | [**ServiceConnections**](ServiceConnections.md)| Created | [optional]
+
+### Return type
+
+[**ServiceConnections**](ServiceConnections.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_service_connections_by_id**
+> delete_service_connections_by_id(id)
+
+Delete a service connection
+
+Delete a service connection.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionsApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a service connection
+ api_instance.delete_service_connections_by_id(id)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionsApi->delete_service_connections_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_service_connections_by_id**
+> ServiceConnections get_service_connections_by_id(id)
+
+Get a service connection
+
+Get an existing service connection.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionsApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Get a service connection
+ api_response = api_instance.get_service_connections_by_id(id)
+ print("The response of ServiceConnectionsApi->get_service_connections_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionsApi->get_service_connections_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**ServiceConnections**](ServiceConnections.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_service_connections**
+> ServiceConnectionsListResponse list_service_connections(folder, limit=limit, offset=offset, name=name)
+
+List service connections
+
+Retrieve a list of service connections.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connections_list_response import ServiceConnectionsListResponse
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionsApi(api_client)
+ folder = Service Connections # str | The folder in which the resource is defined (default to Service Connections)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+
+ try:
+ # List service connections
+ api_response = api_instance.list_service_connections(folder, limit=limit, offset=offset, name=name)
+ print("The response of ServiceConnectionsApi->list_service_connections:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionsApi->list_service_connections: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [default to Service Connections]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+ **name** | **str**| The name of the configuration resource | [optional]
+
+### Return type
+
+[**ServiceConnectionsListResponse**](ServiceConnectionsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_service_connections_by_id**
+> ServiceConnections update_service_connections_by_id(id, service_connections=service_connections)
+
+Update a service connection
+
+Update an existing service connection.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.ServiceConnectionsApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+ service_connections = scm.deployment_services.ServiceConnections() # ServiceConnections | OK (optional)
+
+ try:
+ # Update a service connection
+ api_response = api_instance.update_service_connections_by_id(id, service_connections=service_connections)
+ print("The response of ServiceConnectionsApi->update_service_connections_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceConnectionsApi->update_service_connections_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **service_connections** | [**ServiceConnections**](ServiceConnections.md)| OK | [optional]
+
+### Return type
+
+[**ServiceConnections**](ServiceConnections.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/ServiceConnectionsBgpPeer.md b/scm/deployment_services/docs/ServiceConnectionsBgpPeer.md
new file mode 100644
index 00000000..51cc9af2
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionsBgpPeer.md
@@ -0,0 +1,33 @@
+# ServiceConnectionsBgpPeer
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**local_ip_address** | **str** | | [optional]
+**local_ipv6_address** | **str** | | [optional]
+**peer_ip_address** | **str** | | [optional]
+**peer_ipv6_address** | **str** | | [optional]
+**secret** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connections_bgp_peer import ServiceConnectionsBgpPeer
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnectionsBgpPeer from a JSON string
+service_connections_bgp_peer_instance = ServiceConnectionsBgpPeer.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnectionsBgpPeer.to_json())
+
+# convert the object into a dict
+service_connections_bgp_peer_dict = service_connections_bgp_peer_instance.to_dict()
+# create an instance of ServiceConnectionsBgpPeer from a dict
+service_connections_bgp_peer_from_dict = ServiceConnectionsBgpPeer.from_dict(service_connections_bgp_peer_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnectionsListResponse.md b/scm/deployment_services/docs/ServiceConnectionsListResponse.md
new file mode 100644
index 00000000..1a3cc14b
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionsListResponse.md
@@ -0,0 +1,32 @@
+# ServiceConnectionsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[ServiceConnections]**](ServiceConnections.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connections_list_response import ServiceConnectionsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnectionsListResponse from a JSON string
+service_connections_list_response_instance = ServiceConnectionsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnectionsListResponse.to_json())
+
+# convert the object into a dict
+service_connections_list_response_dict = service_connections_list_response_instance.to_dict()
+# create an instance of ServiceConnectionsListResponse from a dict
+service_connections_list_response_from_dict = ServiceConnectionsListResponse.from_dict(service_connections_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnectionsProtocol.md b/scm/deployment_services/docs/ServiceConnectionsProtocol.md
new file mode 100644
index 00000000..89dadcbd
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionsProtocol.md
@@ -0,0 +1,29 @@
+# ServiceConnectionsProtocol
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bgp** | [**ServiceConnectionsProtocolBgp**](ServiceConnectionsProtocolBgp.md) | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connections_protocol import ServiceConnectionsProtocol
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnectionsProtocol from a JSON string
+service_connections_protocol_instance = ServiceConnectionsProtocol.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnectionsProtocol.to_json())
+
+# convert the object into a dict
+service_connections_protocol_dict = service_connections_protocol_instance.to_dict()
+# create an instance of ServiceConnectionsProtocol from a dict
+service_connections_protocol_from_dict = ServiceConnectionsProtocol.from_dict(service_connections_protocol_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnectionsProtocolBgp.md b/scm/deployment_services/docs/ServiceConnectionsProtocolBgp.md
new file mode 100644
index 00000000..4547c740
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionsProtocolBgp.md
@@ -0,0 +1,37 @@
+# ServiceConnectionsProtocolBgp
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**do_not_export_routes** | **bool** | | [optional]
+**enable** | **bool** | | [optional]
+**fast_failover** | **bool** | | [optional]
+**local_ip_address** | **str** | | [optional]
+**originate_default_route** | **bool** | | [optional]
+**peer_as** | **str** | |
+**peer_ip_address** | **str** | | [optional]
+**secret** | **str** | | [optional]
+**summarize_mobile_user_routes** | **bool** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connections_protocol_bgp import ServiceConnectionsProtocolBgp
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnectionsProtocolBgp from a JSON string
+service_connections_protocol_bgp_instance = ServiceConnectionsProtocolBgp.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnectionsProtocolBgp.to_json())
+
+# convert the object into a dict
+service_connections_protocol_bgp_dict = service_connections_protocol_bgp_instance.to_dict()
+# create an instance of ServiceConnectionsProtocolBgp from a dict
+service_connections_protocol_bgp_from_dict = ServiceConnectionsProtocolBgp.from_dict(service_connections_protocol_bgp_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/ServiceConnectionsQos.md b/scm/deployment_services/docs/ServiceConnectionsQos.md
new file mode 100644
index 00000000..3d8278da
--- /dev/null
+++ b/scm/deployment_services/docs/ServiceConnectionsQos.md
@@ -0,0 +1,30 @@
+# ServiceConnectionsQos
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**enable** | **bool** | | [optional]
+**qos_profile** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.service_connections_qos import ServiceConnectionsQos
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceConnectionsQos from a JSON string
+service_connections_qos_instance = ServiceConnectionsQos.from_json(json)
+# print the JSON string representation of the object
+print(ServiceConnectionsQos.to_json())
+
+# convert the object into a dict
+service_connections_qos_dict = service_connections_qos_instance.to_dict()
+# create an instance of ServiceConnectionsQos from a dict
+service_connections_qos_from_dict = ServiceConnectionsQos.from_dict(service_connections_qos_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/SharedInfrastructureSettings.md b/scm/deployment_services/docs/SharedInfrastructureSettings.md
new file mode 100644
index 00000000..70203817
--- /dev/null
+++ b/scm/deployment_services/docs/SharedInfrastructureSettings.md
@@ -0,0 +1,40 @@
+# SharedInfrastructureSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**api_key** | **str** | | [optional]
+**captive_portal_redirect_ip_address** | **str** | | [optional]
+**connector_application_blocks** | [**EditSharedInfrastructureSettingsConnectorApplicationBlocks**](EditSharedInfrastructureSettingsConnectorApplicationBlocks.md) | | [optional]
+**connector_connector_blocks** | [**EditSharedInfrastructureSettingsConnectorConnectorBlocks**](EditSharedInfrastructureSettingsConnectorConnectorBlocks.md) | | [optional]
+**egress_ip_notification_url** | **str** | | [optional]
+**folder** | **str** | The folder containing the shared infrastructure settings | [optional] [readonly] [default to 'Shared']
+**infra_bgp_as** | **str** | | [optional]
+**infrastructure_subnet** | **str** | | [optional]
+**infrastructure_subnet_ipv6** | **str** | | [optional]
+**ipv6** | **bool** | | [optional]
+**loopback_ips** | **List[str]** | | [optional]
+**tunnel_monitor_ip_address** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.shared_infrastructure_settings import SharedInfrastructureSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SharedInfrastructureSettings from a JSON string
+shared_infrastructure_settings_instance = SharedInfrastructureSettings.from_json(json)
+# print the JSON string representation of the object
+print(SharedInfrastructureSettings.to_json())
+
+# convert the object into a dict
+shared_infrastructure_settings_dict = shared_infrastructure_settings_instance.to_dict()
+# create an instance of SharedInfrastructureSettings from a dict
+shared_infrastructure_settings_from_dict = SharedInfrastructureSettings.from_dict(shared_infrastructure_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/SharedInfrastructureSettingsApi.md b/scm/deployment_services/docs/SharedInfrastructureSettingsApi.md
new file mode 100644
index 00000000..abae6754
--- /dev/null
+++ b/scm/deployment_services/docs/SharedInfrastructureSettingsApi.md
@@ -0,0 +1,174 @@
+# scm.deployment_services.SharedInfrastructureSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**get_shared_infrastructure_settings**](SharedInfrastructureSettingsApi.md#get_shared_infrastructure_settings) | **GET** /shared-infrastructure-settings | Get shared infrastructure settings
+[**update_shared_infrastructure_settings**](SharedInfrastructureSettingsApi.md#update_shared_infrastructure_settings) | **PUT** /shared-infrastructure-settings | Update infrastructure settings
+
+
+# **get_shared_infrastructure_settings**
+> SharedInfrastructureSettings get_shared_infrastructure_settings()
+
+Get shared infrastructure settings
+
+Get the Prisma Access shared infrastructure settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.shared_infrastructure_settings import SharedInfrastructureSettings
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.SharedInfrastructureSettingsApi(api_client)
+
+ try:
+ # Get shared infrastructure settings
+ api_response = api_instance.get_shared_infrastructure_settings()
+ print("The response of SharedInfrastructureSettingsApi->get_shared_infrastructure_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SharedInfrastructureSettingsApi->get_shared_infrastructure_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+This endpoint does not need any parameter.
+
+### Return type
+
+[**SharedInfrastructureSettings**](SharedInfrastructureSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_shared_infrastructure_settings**
+> SharedInfrastructureSettings update_shared_infrastructure_settings(edit_shared_infrastructure_settings=edit_shared_infrastructure_settings)
+
+Update infrastructure settings
+
+Update the Prisma Access shared infrastructure settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.edit_shared_infrastructure_settings import EditSharedInfrastructureSettings
+from scm.deployment_services.models.shared_infrastructure_settings import SharedInfrastructureSettings
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.SharedInfrastructureSettingsApi(api_client)
+ edit_shared_infrastructure_settings = scm.deployment_services.EditSharedInfrastructureSettings() # EditSharedInfrastructureSettings | OK (optional)
+
+ try:
+ # Update infrastructure settings
+ api_response = api_instance.update_shared_infrastructure_settings(edit_shared_infrastructure_settings=edit_shared_infrastructure_settings)
+ print("The response of SharedInfrastructureSettingsApi->update_shared_infrastructure_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SharedInfrastructureSettingsApi->update_shared_infrastructure_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **edit_shared_infrastructure_settings** | [**EditSharedInfrastructureSettings**](EditSharedInfrastructureSettings.md)| OK | [optional]
+
+### Return type
+
+[**SharedInfrastructureSettings**](SharedInfrastructureSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/Sites.md b/scm/deployment_services/docs/Sites.md
new file mode 100644
index 00000000..7522d218
--- /dev/null
+++ b/scm/deployment_services/docs/Sites.md
@@ -0,0 +1,42 @@
+# Sites
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**address_line_1** | **str** | The address in which the site exists | [optional]
+**address_line_2** | **str** | The address in which the site exists (continued) | [optional]
+**city** | **str** | The city in which the site exists | [optional]
+**country** | **str** | The country in which the site exists | [optional]
+**id** | **str** | The UUID of the site | [optional] [readonly]
+**latitude** | **str** | The latitude coordinate for the site | [optional]
+**license_type** | **str** | The license type of the site | [optional]
+**longitude** | **str** | The longitude coordinate for the site | [optional]
+**members** | [**List[SitesMembersInner]**](SitesMembersInner.md) | | [optional]
+**name** | **str** | The name of the site |
+**qos** | [**SitesQos**](SitesQos.md) | | [optional]
+**state** | **str** | The state in which the site exists | [optional]
+**type** | **str** | The site type | [optional]
+**zip_code** | **str** | The postal code in which the site exists | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.sites import Sites
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of Sites from a JSON string
+sites_instance = Sites.from_json(json)
+# print the JSON string representation of the object
+print(Sites.to_json())
+
+# convert the object into a dict
+sites_dict = sites_instance.to_dict()
+# create an instance of Sites from a dict
+sites_from_dict = Sites.from_dict(sites_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/SitesApi.md b/scm/deployment_services/docs/SitesApi.md
new file mode 100644
index 00000000..5fe8c8f9
--- /dev/null
+++ b/scm/deployment_services/docs/SitesApi.md
@@ -0,0 +1,435 @@
+# scm.deployment_services.SitesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_sites**](SitesApi.md#create_sites) | **POST** /sites | Create a site
+[**delete_sites_by_id**](SitesApi.md#delete_sites_by_id) | **DELETE** /sites/{id} | Delete a site
+[**get_sites_by_id**](SitesApi.md#get_sites_by_id) | **GET** /sites/{id} | Get a site
+[**list_sites**](SitesApi.md#list_sites) | **GET** /sites | List sites
+[**update_sites_by_id**](SitesApi.md#update_sites_by_id) | **PUT** /sites/{id} | Update a site
+
+
+# **create_sites**
+> Sites create_sites(sites=sites)
+
+Create a site
+
+Create a new sites.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.sites import Sites
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.SitesApi(api_client)
+ sites = scm.deployment_services.Sites() # Sites | The site you want to create (optional)
+
+ try:
+ # Create a site
+ api_response = api_instance.create_sites(sites=sites)
+ print("The response of SitesApi->create_sites:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SitesApi->create_sites: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **sites** | [**Sites**](Sites.md)| The site you want to create | [optional]
+
+### Return type
+
+[**Sites**](Sites.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Successful response | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_sites_by_id**
+> delete_sites_by_id(id)
+
+Delete a site
+
+Delete a site.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.SitesApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a site
+ api_instance.delete_sites_by_id(id)
+ except Exception as e:
+ print("Exception when calling SitesApi->delete_sites_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_sites_by_id**
+> Sites get_sites_by_id(id)
+
+Get a site
+
+Get an existing site.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.sites import Sites
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.SitesApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Get a site
+ api_response = api_instance.get_sites_by_id(id)
+ print("The response of SitesApi->get_sites_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SitesApi->get_sites_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**Sites**](Sites.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | Get a site's details by sdwan-site-id. | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_sites**
+> SitesListResponse list_sites(folder, limit=limit, offset=offset, name=name)
+
+List sites
+
+Retrieve a list of sites.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.sites_list_response import SitesListResponse
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.SitesApi(api_client)
+ folder = Remote Networks # str | The folder in which the resource is defined (default to Remote Networks)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+
+ try:
+ # List sites
+ api_response = api_instance.list_sites(folder, limit=limit, offset=offset, name=name)
+ print("The response of SitesApi->list_sites:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SitesApi->list_sites: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [default to Remote Networks]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+ **name** | **str**| The name of the configuration resource | [optional]
+
+### Return type
+
+[**SitesListResponse**](SitesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_sites_by_id**
+> Sites update_sites_by_id(id, sites=sites)
+
+Update a site
+
+Update an existing site.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.sites import Sites
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.SitesApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+ sites = scm.deployment_services.Sites() # Sites | The site you want to edit (optional)
+
+ try:
+ # Update a site
+ api_response = api_instance.update_sites_by_id(id, sites=sites)
+ print("The response of SitesApi->update_sites_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SitesApi->update_sites_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **sites** | [**Sites**](Sites.md)| The site you want to edit | [optional]
+
+### Return type
+
+[**Sites**](Sites.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | Successful response | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/SitesListResponse.md b/scm/deployment_services/docs/SitesListResponse.md
new file mode 100644
index 00000000..f3ac0d20
--- /dev/null
+++ b/scm/deployment_services/docs/SitesListResponse.md
@@ -0,0 +1,32 @@
+# SitesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[Sites]**](Sites.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.deployment_services.models.sites_list_response import SitesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SitesListResponse from a JSON string
+sites_list_response_instance = SitesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(SitesListResponse.to_json())
+
+# convert the object into a dict
+sites_list_response_dict = sites_list_response_instance.to_dict()
+# create an instance of SitesListResponse from a dict
+sites_list_response_from_dict = SitesListResponse.from_dict(sites_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/SitesMembersInner.md b/scm/deployment_services/docs/SitesMembersInner.md
new file mode 100644
index 00000000..853bf681
--- /dev/null
+++ b/scm/deployment_services/docs/SitesMembersInner.md
@@ -0,0 +1,32 @@
+# SitesMembersInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**id** | **str** | UUID of the remote network | [optional] [readonly]
+**mode** | **str** | The mode of the remote network |
+**name** | **str** | The member name |
+**remote_network** | **str** | The remote network name | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.sites_members_inner import SitesMembersInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SitesMembersInner from a JSON string
+sites_members_inner_instance = SitesMembersInner.from_json(json)
+# print the JSON string representation of the object
+print(SitesMembersInner.to_json())
+
+# convert the object into a dict
+sites_members_inner_dict = sites_members_inner_instance.to_dict()
+# create an instance of SitesMembersInner from a dict
+sites_members_inner_from_dict = SitesMembersInner.from_dict(sites_members_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/SitesQos.md b/scm/deployment_services/docs/SitesQos.md
new file mode 100644
index 00000000..cc084cff
--- /dev/null
+++ b/scm/deployment_services/docs/SitesQos.md
@@ -0,0 +1,31 @@
+# SitesQos
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**backup_cir** | **float** | The backup CIR in Mbps. This is distributed equally for all tunnels in the site. | [optional]
+**cir** | **float** | The CIR in Mbps. This is distributed equally for all tunnels in the site. | [optional]
+**profile** | **str** | The name of the site QoS profile | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.sites_qos import SitesQos
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SitesQos from a JSON string
+sites_qos_instance = SitesQos.from_json(json)
+# print the JSON string representation of the object
+print(SitesQos.to_json())
+
+# convert the object into a dict
+sites_qos_dict = sites_qos_instance.to_dict()
+# create an instance of SitesQos from a dict
+sites_qos_from_dict = SitesQos.from_dict(sites_qos_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/TrafficSteeringRules.md b/scm/deployment_services/docs/TrafficSteeringRules.md
new file mode 100644
index 00000000..a82a21d2
--- /dev/null
+++ b/scm/deployment_services/docs/TrafficSteeringRules.md
@@ -0,0 +1,37 @@
+# TrafficSteeringRules
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | [**TrafficSteeringRulesAction**](TrafficSteeringRulesAction.md) | | [optional]
+**category** | **List[str]** | | [optional]
+**destination** | **List[str]** | | [optional] [default to ["any"]]
+**folder** | **str** | The folder containing the traffic steering rule | [optional] [default to 'Service Connections']
+**id** | **str** | The UUID of the traffic steering rule | [readonly]
+**name** | **str** | |
+**service** | **List[str]** | | [default to ["any"]]
+**source** | **List[str]** | | [default to ["any"]]
+**source_user** | **List[str]** | | [optional] [default to ["any"]]
+
+## Example
+
+```python
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrafficSteeringRules from a JSON string
+traffic_steering_rules_instance = TrafficSteeringRules.from_json(json)
+# print the JSON string representation of the object
+print(TrafficSteeringRules.to_json())
+
+# convert the object into a dict
+traffic_steering_rules_dict = traffic_steering_rules_instance.to_dict()
+# create an instance of TrafficSteeringRules from a dict
+traffic_steering_rules_from_dict = TrafficSteeringRules.from_dict(traffic_steering_rules_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/TrafficSteeringRulesAction.md b/scm/deployment_services/docs/TrafficSteeringRulesAction.md
new file mode 100644
index 00000000..7d047fcb
--- /dev/null
+++ b/scm/deployment_services/docs/TrafficSteeringRulesAction.md
@@ -0,0 +1,29 @@
+# TrafficSteeringRulesAction
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**forward** | [**TrafficSteeringRulesActionForward**](TrafficSteeringRulesActionForward.md) | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.traffic_steering_rules_action import TrafficSteeringRulesAction
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrafficSteeringRulesAction from a JSON string
+traffic_steering_rules_action_instance = TrafficSteeringRulesAction.from_json(json)
+# print the JSON string representation of the object
+print(TrafficSteeringRulesAction.to_json())
+
+# convert the object into a dict
+traffic_steering_rules_action_dict = traffic_steering_rules_action_instance.to_dict()
+# create an instance of TrafficSteeringRulesAction from a dict
+traffic_steering_rules_action_from_dict = TrafficSteeringRulesAction.from_dict(traffic_steering_rules_action_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/TrafficSteeringRulesActionForward.md b/scm/deployment_services/docs/TrafficSteeringRulesActionForward.md
new file mode 100644
index 00000000..2dd8872a
--- /dev/null
+++ b/scm/deployment_services/docs/TrafficSteeringRulesActionForward.md
@@ -0,0 +1,30 @@
+# TrafficSteeringRulesActionForward
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**forward** | [**TrafficSteeringRulesActionForwardForward**](TrafficSteeringRulesActionForwardForward.md) | | [optional]
+**no_pbf** | **object** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.traffic_steering_rules_action_forward import TrafficSteeringRulesActionForward
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrafficSteeringRulesActionForward from a JSON string
+traffic_steering_rules_action_forward_instance = TrafficSteeringRulesActionForward.from_json(json)
+# print the JSON string representation of the object
+print(TrafficSteeringRulesActionForward.to_json())
+
+# convert the object into a dict
+traffic_steering_rules_action_forward_dict = traffic_steering_rules_action_forward_instance.to_dict()
+# create an instance of TrafficSteeringRulesActionForward from a dict
+traffic_steering_rules_action_forward_from_dict = TrafficSteeringRulesActionForward.from_dict(traffic_steering_rules_action_forward_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/TrafficSteeringRulesActionForwardForward.md b/scm/deployment_services/docs/TrafficSteeringRulesActionForwardForward.md
new file mode 100644
index 00000000..42ee49d9
--- /dev/null
+++ b/scm/deployment_services/docs/TrafficSteeringRulesActionForwardForward.md
@@ -0,0 +1,29 @@
+# TrafficSteeringRulesActionForwardForward
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**target** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.deployment_services.models.traffic_steering_rules_action_forward_forward import TrafficSteeringRulesActionForwardForward
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrafficSteeringRulesActionForwardForward from a JSON string
+traffic_steering_rules_action_forward_forward_instance = TrafficSteeringRulesActionForwardForward.from_json(json)
+# print the JSON string representation of the object
+print(TrafficSteeringRulesActionForwardForward.to_json())
+
+# convert the object into a dict
+traffic_steering_rules_action_forward_forward_dict = traffic_steering_rules_action_forward_forward_instance.to_dict()
+# create an instance of TrafficSteeringRulesActionForwardForward from a dict
+traffic_steering_rules_action_forward_forward_from_dict = TrafficSteeringRulesActionForwardForward.from_dict(traffic_steering_rules_action_forward_forward_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/docs/TrafficSteeringRulesApi.md b/scm/deployment_services/docs/TrafficSteeringRulesApi.md
new file mode 100644
index 00000000..c981c3b8
--- /dev/null
+++ b/scm/deployment_services/docs/TrafficSteeringRulesApi.md
@@ -0,0 +1,437 @@
+# scm.deployment_services.TrafficSteeringRulesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/deployment/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_traffic_steering_rules**](TrafficSteeringRulesApi.md#create_traffic_steering_rules) | **POST** /traffic-steering-rules | Create a traffic steering rule
+[**delete_traffic_steering_rules_by_id**](TrafficSteeringRulesApi.md#delete_traffic_steering_rules_by_id) | **DELETE** /traffic-steering-rules/{id} | Delete a traffic steering rule
+[**get_traffic_steering_rules_by_id**](TrafficSteeringRulesApi.md#get_traffic_steering_rules_by_id) | **GET** /traffic-steering-rules/{id} | Get a traffic steering rule
+[**list_traffic_steering_rules**](TrafficSteeringRulesApi.md#list_traffic_steering_rules) | **GET** /traffic-steering-rules | List traffic steering rules
+[**update_traffic_steering_rules_by_id**](TrafficSteeringRulesApi.md#update_traffic_steering_rules_by_id) | **PUT** /traffic-steering-rules/{id} | Update a traffic steering rule
+
+
+# **create_traffic_steering_rules**
+> TrafficSteeringRules create_traffic_steering_rules(folder, traffic_steering_rules=traffic_steering_rules)
+
+Create a traffic steering rule
+
+Create a new Service Connection traffic steering rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.TrafficSteeringRulesApi(api_client)
+ folder = Service Connections # str | The folder in which the resource is defined (default to Service Connections)
+ traffic_steering_rules = scm.deployment_services.TrafficSteeringRules() # TrafficSteeringRules | Created (optional)
+
+ try:
+ # Create a traffic steering rule
+ api_response = api_instance.create_traffic_steering_rules(folder, traffic_steering_rules=traffic_steering_rules)
+ print("The response of TrafficSteeringRulesApi->create_traffic_steering_rules:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrafficSteeringRulesApi->create_traffic_steering_rules: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [default to Service Connections]
+ **traffic_steering_rules** | [**TrafficSteeringRules**](TrafficSteeringRules.md)| Created | [optional]
+
+### Return type
+
+[**TrafficSteeringRules**](TrafficSteeringRules.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_traffic_steering_rules_by_id**
+> delete_traffic_steering_rules_by_id(id)
+
+Delete a traffic steering rule
+
+Delete a Service Connection traffic steering rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.TrafficSteeringRulesApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a traffic steering rule
+ api_instance.delete_traffic_steering_rules_by_id(id)
+ except Exception as e:
+ print("Exception when calling TrafficSteeringRulesApi->delete_traffic_steering_rules_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_traffic_steering_rules_by_id**
+> TrafficSteeringRules get_traffic_steering_rules_by_id(id)
+
+Get a traffic steering rule
+
+Get an existing Service Connection traffic steering rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.TrafficSteeringRulesApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+
+ try:
+ # Get a traffic steering rule
+ api_response = api_instance.get_traffic_steering_rules_by_id(id)
+ print("The response of TrafficSteeringRulesApi->get_traffic_steering_rules_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrafficSteeringRulesApi->get_traffic_steering_rules_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**TrafficSteeringRules**](TrafficSteeringRules.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_traffic_steering_rules**
+> TrafficSteeringRulesListResponse list_traffic_steering_rules(folder, name=name, limit=limit, offset=offset)
+
+List traffic steering rules
+
+Retrieve a list of Service Connection traffic steering rules.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.traffic_steering_rules_list_response import TrafficSteeringRulesListResponse
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.TrafficSteeringRulesApi(api_client)
+ folder = Service Connections # str | The folder in which the resource is defined (default to Service Connections)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List traffic steering rules
+ api_response = api_instance.list_traffic_steering_rules(folder, name=name, limit=limit, offset=offset)
+ print("The response of TrafficSteeringRulesApi->list_traffic_steering_rules:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrafficSteeringRulesApi->list_traffic_steering_rules: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [default to Service Connections]
+ **name** | **str**| The name of the configuration resource | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**TrafficSteeringRulesListResponse**](TrafficSteeringRulesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_traffic_steering_rules_by_id**
+> TrafficSteeringRules update_traffic_steering_rules_by_id(id, traffic_steering_rules=traffic_steering_rules)
+
+Update a traffic steering rule
+
+Update an existing Service Connection traffic steering rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.deployment_services
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from scm.deployment_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/deployment/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.deployment_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/deployment/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.deployment_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.deployment_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.deployment_services.TrafficSteeringRulesApi(api_client)
+ id = 'id_example' # str | The UUID of the configuration resource
+ traffic_steering_rules = scm.deployment_services.TrafficSteeringRules() # TrafficSteeringRules | OK (optional)
+
+ try:
+ # Update a traffic steering rule
+ api_response = api_instance.update_traffic_steering_rules_by_id(id, traffic_steering_rules=traffic_steering_rules)
+ print("The response of TrafficSteeringRulesApi->update_traffic_steering_rules_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrafficSteeringRulesApi->update_traffic_steering_rules_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **traffic_steering_rules** | [**TrafficSteeringRules**](TrafficSteeringRules.md)| OK | [optional]
+
+### Return type
+
+[**TrafficSteeringRules**](TrafficSteeringRules.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/deployment_services/docs/TrafficSteeringRulesListResponse.md b/scm/deployment_services/docs/TrafficSteeringRulesListResponse.md
new file mode 100644
index 00000000..537f5c5c
--- /dev/null
+++ b/scm/deployment_services/docs/TrafficSteeringRulesListResponse.md
@@ -0,0 +1,32 @@
+# TrafficSteeringRulesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[TrafficSteeringRules]**](TrafficSteeringRules.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.deployment_services.models.traffic_steering_rules_list_response import TrafficSteeringRulesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrafficSteeringRulesListResponse from a JSON string
+traffic_steering_rules_list_response_instance = TrafficSteeringRulesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(TrafficSteeringRulesListResponse.to_json())
+
+# convert the object into a dict
+traffic_steering_rules_list_response_dict = traffic_steering_rules_list_response_instance.to_dict()
+# create an instance of TrafficSteeringRulesListResponse from a dict
+traffic_steering_rules_list_response_from_dict = TrafficSteeringRulesListResponse.from_dict(traffic_steering_rules_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/deployment_services/exceptions.py b/scm/deployment_services/exceptions.py
new file mode 100644
index 00000000..e6160a4b
--- /dev/null
+++ b/scm/deployment_services/exceptions.py
@@ -0,0 +1,200 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+from typing import Any, Optional
+from typing_extensions import Self
+
+class OpenApiException(Exception):
+ """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+ def __init__(self, msg, path_to_item=None, valid_classes=None,
+ key_type=None) -> None:
+ """ Raises an exception for TypeErrors
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list): a list of keys an indices to get to the
+ current_item
+ None if unset
+ valid_classes (tuple): the primitive classes that current item
+ should be an instance of
+ None if unset
+ key_type (bool): False if our value is a value in a dict
+ True if it is a key in a dict
+ False if our item is an item in a list
+ None if unset
+ """
+ self.path_to_item = path_to_item
+ self.valid_classes = valid_classes
+ self.key_type = key_type
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list) the path to the exception in the
+ received_data dict. None if unset
+ """
+
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Raised when an attribute reference or assignment fails.
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+ def __init__(
+ self,
+ status=None,
+ reason=None,
+ http_resp=None,
+ *,
+ body: Optional[str] = None,
+ data: Optional[Any] = None,
+ ) -> None:
+ self.status = status
+ self.reason = reason
+ self.body = body
+ self.data = data
+ self.headers = None
+
+ if http_resp:
+ if self.status is None:
+ self.status = http_resp.status
+ if self.reason is None:
+ self.reason = http_resp.reason
+ if self.body is None:
+ try:
+ self.body = http_resp.data.decode('utf-8')
+ except Exception:
+ pass
+ self.headers = http_resp.getheaders()
+
+ @classmethod
+ def from_response(
+ cls,
+ *,
+ http_resp,
+ body: Optional[str],
+ data: Optional[Any],
+ ) -> Self:
+ if http_resp.status == 400:
+ raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 401:
+ raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 403:
+ raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 404:
+ raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+ if 500 <= http_resp.status <= 599:
+ raise ServiceException(http_resp=http_resp, body=body, data=data)
+ raise ApiException(http_resp=http_resp, body=body, data=data)
+
+ def __str__(self):
+ """Custom error messages for exception"""
+ error_message = "({0})\n"\
+ "Reason: {1}\n".format(self.status, self.reason)
+ if self.headers:
+ error_message += "HTTP response headers: {0}\n".format(
+ self.headers)
+
+ if self.data or self.body:
+ error_message += "HTTP response body: {0}\n".format(self.data or self.body)
+
+ return error_message
+
+
+class BadRequestException(ApiException):
+ pass
+
+
+class NotFoundException(ApiException):
+ pass
+
+
+class UnauthorizedException(ApiException):
+ pass
+
+
+class ForbiddenException(ApiException):
+ pass
+
+
+class ServiceException(ApiException):
+ pass
+
+
+def render_path(path_to_item):
+ """Returns a string representation of a path"""
+ result = ""
+ for pth in path_to_item:
+ if isinstance(pth, int):
+ result += "[{0}]".format(pth)
+ else:
+ result += "['{0}']".format(pth)
+ return result
diff --git a/scm/deployment_services/models/__init__.py b/scm/deployment_services/models/__init__.py
new file mode 100644
index 00000000..bd6b0b74
--- /dev/null
+++ b/scm/deployment_services/models/__init__.py
@@ -0,0 +1,55 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+# import models into model package
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+from scm.deployment_services.models.bandwidth_allocations_list_response import BandwidthAllocationsListResponse
+from scm.deployment_services.models.bandwidth_allocations_qos import BandwidthAllocationsQos
+from scm.deployment_services.models.bgp_routing import BgpRouting
+from scm.deployment_services.models.bgp_routing_routing_preference import BgpRoutingRoutingPreference
+from scm.deployment_services.models.edit_shared_infrastructure_settings import EditSharedInfrastructureSettings
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_application_blocks import EditSharedInfrastructureSettingsConnectorApplicationBlocks
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_connector_blocks import EditSharedInfrastructureSettingsConnectorConnectorBlocks
+from scm.deployment_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.deployment_services.models.generic_error import GenericError
+from scm.deployment_services.models.internal_dns_servers_list_response import InternalDNSServersListResponse
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+from scm.deployment_services.models.locations import Locations
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner import RemoteNetworksEcmpTunnelsInner
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner_protocol import RemoteNetworksEcmpTunnelsInnerProtocol
+from scm.deployment_services.models.remote_networks_list_response import RemoteNetworksListResponse
+from scm.deployment_services.models.remote_networks_protocol import RemoteNetworksProtocol
+from scm.deployment_services.models.remote_networks_protocol_bgp import RemoteNetworksProtocolBgp
+from scm.deployment_services.models.remote_networks_protocol_bgp_peer import RemoteNetworksProtocolBgpPeer
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from scm.deployment_services.models.service_connection_groups_list_response import ServiceConnectionGroupsListResponse
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.deployment_services.models.service_connections_bgp_peer import ServiceConnectionsBgpPeer
+from scm.deployment_services.models.service_connections_list_response import ServiceConnectionsListResponse
+from scm.deployment_services.models.service_connections_protocol import ServiceConnectionsProtocol
+from scm.deployment_services.models.service_connections_protocol_bgp import ServiceConnectionsProtocolBgp
+from scm.deployment_services.models.service_connections_qos import ServiceConnectionsQos
+from scm.deployment_services.models.shared_infrastructure_settings import SharedInfrastructureSettings
+from scm.deployment_services.models.sites import Sites
+from scm.deployment_services.models.sites_list_response import SitesListResponse
+from scm.deployment_services.models.sites_members_inner import SitesMembersInner
+from scm.deployment_services.models.sites_qos import SitesQos
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from scm.deployment_services.models.traffic_steering_rules_action import TrafficSteeringRulesAction
+from scm.deployment_services.models.traffic_steering_rules_action_forward import TrafficSteeringRulesActionForward
+from scm.deployment_services.models.traffic_steering_rules_action_forward_forward import TrafficSteeringRulesActionForwardForward
+from scm.deployment_services.models.traffic_steering_rules_list_response import TrafficSteeringRulesListResponse
diff --git a/scm/deployment_services/models/bandwidth_allocations.py b/scm/deployment_services/models/bandwidth_allocations.py
new file mode 100644
index 00000000..ab8447d1
--- /dev/null
+++ b/scm/deployment_services/models/bandwidth_allocations.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.bandwidth_allocations_qos import BandwidthAllocationsQos
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BandwidthAllocations(BaseModel):
+ """
+ BandwidthAllocations
+ """ # noqa: E501
+ allocated_bandwidth: StrictInt = Field(description="bandwidth to allocate in Mbps")
+ name: StrictStr = Field(description="name of the aggregated bandwidth region")
+ qos: Optional[BandwidthAllocationsQos] = None
+ spn_name_list: Optional[List[StrictStr]] = None
+ __properties: ClassVar[List[str]] = ["allocated_bandwidth", "name", "qos", "spn_name_list"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of BandwidthAllocations from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of qos
+ if self.qos:
+ _dict['qos'] = self.qos.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of BandwidthAllocations from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "allocated_bandwidth": obj.get("allocated_bandwidth"),
+ "name": obj.get("name"),
+ "qos": BandwidthAllocationsQos.from_dict(obj["qos"]) if obj.get("qos") is not None else None,
+ "spn_name_list": obj.get("spn_name_list")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/bandwidth_allocations_list_response.py b/scm/deployment_services/models/bandwidth_allocations_list_response.py
new file mode 100644
index 00000000..9672ae7d
--- /dev/null
+++ b/scm/deployment_services/models/bandwidth_allocations_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BandwidthAllocationsListResponse(BaseModel):
+ """
+ BandwidthAllocationsListResponse
+ """ # noqa: E501
+ data: List[BandwidthAllocations]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of BandwidthAllocationsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of BandwidthAllocationsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = BandwidthAllocations.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [BandwidthAllocations.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/bandwidth_allocations_qos.py b/scm/deployment_services/models/bandwidth_allocations_qos.py
new file mode 100644
index 00000000..1bb90c8b
--- /dev/null
+++ b/scm/deployment_services/models/bandwidth_allocations_qos.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BandwidthAllocationsQos(BaseModel):
+ """
+ BandwidthAllocationsQos
+ """ # noqa: E501
+ customized: Optional[StrictBool] = False
+ enabled: Optional[StrictBool] = False
+ guaranteed_ratio: Optional[Union[StrictFloat, StrictInt]] = 0
+ profile: Optional[StrictStr] = ''
+ __properties: ClassVar[List[str]] = ["customized", "enabled", "guaranteed_ratio", "profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of BandwidthAllocationsQos from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of BandwidthAllocationsQos from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "customized": obj.get("customized") if obj.get("customized") is not None else False,
+ "enabled": obj.get("enabled") if obj.get("enabled") is not None else False,
+ "guaranteed_ratio": obj.get("guaranteed_ratio") if obj.get("guaranteed_ratio") is not None else 0,
+ "profile": obj.get("profile") if obj.get("profile") is not None else ''
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/bgp_routing.py b/scm/deployment_services/models/bgp_routing.py
new file mode 100644
index 00000000..29787e96
--- /dev/null
+++ b/scm/deployment_services/models/bgp_routing.py
@@ -0,0 +1,112 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.bgp_routing_routing_preference import BgpRoutingRoutingPreference
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BgpRouting(BaseModel):
+ """
+ BgpRouting
+ """ # noqa: E501
+ accept_route_over_sc: Optional[StrictBool] = Field(default=None, alias="accept_route_over_SC")
+ add_host_route_to_ike_peer: Optional[StrictBool] = None
+ backbone_routing: Optional[StrictStr] = None
+ outbound_routes_for_services: Optional[List[StrictStr]] = None
+ routing_preference: Optional[BgpRoutingRoutingPreference] = None
+ withdraw_static_route: Optional[StrictBool] = None
+ __properties: ClassVar[List[str]] = ["accept_route_over_SC", "add_host_route_to_ike_peer", "backbone_routing", "outbound_routes_for_services", "routing_preference", "withdraw_static_route"]
+
+ @field_validator('backbone_routing')
+ def backbone_routing_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['no-asymmetric-routing', 'asymmetric-routing-only', 'asymmetric-routing-with-load-share']):
+ raise ValueError("must be one of enum values ('no-asymmetric-routing', 'asymmetric-routing-only', 'asymmetric-routing-with-load-share')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of BgpRouting from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of routing_preference
+ if self.routing_preference:
+ _dict['routing_preference'] = self.routing_preference.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of BgpRouting from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "accept_route_over_SC": obj.get("accept_route_over_SC"),
+ "add_host_route_to_ike_peer": obj.get("add_host_route_to_ike_peer"),
+ "backbone_routing": obj.get("backbone_routing"),
+ "outbound_routes_for_services": obj.get("outbound_routes_for_services"),
+ "routing_preference": BgpRoutingRoutingPreference.from_dict(obj["routing_preference"]) if obj.get("routing_preference") is not None else None,
+ "withdraw_static_route": obj.get("withdraw_static_route")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/bgp_routing_routing_preference.py b/scm/deployment_services/models/bgp_routing_routing_preference.py
new file mode 100644
index 00000000..4d17c2ed
--- /dev/null
+++ b/scm/deployment_services/models/bgp_routing_routing_preference.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class BgpRoutingRoutingPreference(BaseModel):
+ """
+ BgpRoutingRoutingPreference
+ """ # noqa: E501
+ default: Optional[Dict[str, Any]] = None
+ hot_potato_routing: Optional[Dict[str, Any]] = None
+ __properties: ClassVar[List[str]] = ["default", "hot_potato_routing"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of BgpRoutingRoutingPreference from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of BgpRoutingRoutingPreference from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "default": obj.get("default"),
+ "hot_potato_routing": obj.get("hot_potato_routing")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/edit_shared_infrastructure_settings.py b/scm/deployment_services/models/edit_shared_infrastructure_settings.py
new file mode 100644
index 00000000..22f1b38c
--- /dev/null
+++ b/scm/deployment_services/models/edit_shared_infrastructure_settings.py
@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_application_blocks import EditSharedInfrastructureSettingsConnectorApplicationBlocks
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_connector_blocks import EditSharedInfrastructureSettingsConnectorConnectorBlocks
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EditSharedInfrastructureSettings(BaseModel):
+ """
+ EditSharedInfrastructureSettings
+ """ # noqa: E501
+ connector_application_blocks: Optional[EditSharedInfrastructureSettingsConnectorApplicationBlocks] = Field(default=None, alias="connector-application-blocks")
+ connector_connector_blocks: Optional[EditSharedInfrastructureSettingsConnectorConnectorBlocks] = Field(default=None, alias="connector-connector-blocks")
+ egress_ip_notification_url: Optional[StrictStr] = None
+ infra_bgp_as: Optional[StrictStr] = None
+ infrastructure_subnet: Optional[StrictStr] = None
+ infrastructure_subnet_ipv6: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["connector-application-blocks", "connector-connector-blocks", "egress_ip_notification_url", "infra_bgp_as", "infrastructure_subnet", "infrastructure_subnet_ipv6"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of EditSharedInfrastructureSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of connector_application_blocks
+ if self.connector_application_blocks:
+ _dict['connector-application-blocks'] = self.connector_application_blocks.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of connector_connector_blocks
+ if self.connector_connector_blocks:
+ _dict['connector-connector-blocks'] = self.connector_connector_blocks.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of EditSharedInfrastructureSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "connector-application-blocks": EditSharedInfrastructureSettingsConnectorApplicationBlocks.from_dict(obj["connector-application-blocks"]) if obj.get("connector-application-blocks") is not None else None,
+ "connector-connector-blocks": EditSharedInfrastructureSettingsConnectorConnectorBlocks.from_dict(obj["connector-connector-blocks"]) if obj.get("connector-connector-blocks") is not None else None,
+ "egress_ip_notification_url": obj.get("egress_ip_notification_url"),
+ "infra_bgp_as": obj.get("infra_bgp_as"),
+ "infrastructure_subnet": obj.get("infrastructure_subnet"),
+ "infrastructure_subnet_ipv6": obj.get("infrastructure_subnet_ipv6")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/edit_shared_infrastructure_settings_connector_application_blocks.py b/scm/deployment_services/models/edit_shared_infrastructure_settings_connector_application_blocks.py
new file mode 100644
index 00000000..9966cc64
--- /dev/null
+++ b/scm/deployment_services/models/edit_shared_infrastructure_settings_connector_application_blocks.py
@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EditSharedInfrastructureSettingsConnectorApplicationBlocks(BaseModel):
+ """
+ EditSharedInfrastructureSettingsConnectorApplicationBlocks
+ """ # noqa: E501
+ member: Optional[Annotated[List[Annotated[str, Field(strict=True)]], Field(max_length=100)]] = Field(default=None, description="Array of CIDR blocks for connector-to-application communication")
+ __properties: ClassVar[List[str]] = ["member"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of EditSharedInfrastructureSettingsConnectorApplicationBlocks from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of EditSharedInfrastructureSettingsConnectorApplicationBlocks from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "member": obj.get("member")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/edit_shared_infrastructure_settings_connector_connector_blocks.py b/scm/deployment_services/models/edit_shared_infrastructure_settings_connector_connector_blocks.py
new file mode 100644
index 00000000..18119b76
--- /dev/null
+++ b/scm/deployment_services/models/edit_shared_infrastructure_settings_connector_connector_blocks.py
@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EditSharedInfrastructureSettingsConnectorConnectorBlocks(BaseModel):
+ """
+ EditSharedInfrastructureSettingsConnectorConnectorBlocks
+ """ # noqa: E501
+ member: Optional[Annotated[List[Annotated[str, Field(strict=True)]], Field(max_length=100)]] = Field(default=None, description="Array of CIDR blocks for connector-to-connector communication")
+ __properties: ClassVar[List[str]] = ["member"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of EditSharedInfrastructureSettingsConnectorConnectorBlocks from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of EditSharedInfrastructureSettingsConnectorConnectorBlocks from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "member": obj.get("member")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/error_detail_cause_info.py b/scm/deployment_services/models/error_detail_cause_info.py
new file mode 100644
index 00000000..5b18246a
--- /dev/null
+++ b/scm/deployment_services/models/error_detail_cause_info.py
@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorDetailCauseInfo(BaseModel):
+ """
+ ErrorDetailCauseInfo
+ """ # noqa: E501
+ code: Optional[StrictStr] = None
+ details: Optional[Any] = None
+ help: Optional[StrictStr] = None
+ message: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["code", "details", "help", "message"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if details (nullable) is None
+ # and model_fields_set contains the field
+ if self.details is None and "details" in self.model_fields_set:
+ _dict['details'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "code": obj.get("code"),
+ "details": obj.get("details"),
+ "help": obj.get("help"),
+ "message": obj.get("message")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/generic_error.py b/scm/deployment_services/models/generic_error.py
new file mode 100644
index 00000000..efe5b2d1
--- /dev/null
+++ b/scm/deployment_services/models/generic_error.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GenericError(BaseModel):
+ """
+ GenericError
+ """ # noqa: E501
+ errors: Optional[List[ErrorDetailCauseInfo]] = Field(default=None, alias="_errors")
+ request_id: Optional[StrictStr] = Field(default=None, alias="_request_id")
+ __properties: ClassVar[List[str]] = ["_errors", "_request_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GenericError from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+ _items = []
+ if self.errors:
+ for _item_errors in self.errors:
+ if _item_errors:
+ _items.append(_item_errors.to_dict())
+ _dict['_errors'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GenericError from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "_errors": [ErrorDetailCauseInfo.from_dict(_item) for _item in obj["_errors"]] if obj.get("_errors") is not None else None,
+ "_request_id": obj.get("_request_id")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/internal_dns_servers.py b/scm/deployment_services/models/internal_dns_servers.py
new file mode 100644
index 00000000..6cac1fb6
--- /dev/null
+++ b/scm/deployment_services/models/internal_dns_servers.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InternalDnsServers(BaseModel):
+ """
+ InternalDnsServers
+ """ # noqa: E501
+ domain_name: List[StrictStr] = Field(description="The DNS domain name(s)")
+ id: StrictStr = Field(description="The UUID of the internet DNS server resource")
+ name: StrictStr = Field(description="The name of the internet DNS server resource")
+ primary: StrictStr = Field(description="The IP address of the primary DNS server")
+ secondary: Optional[StrictStr] = Field(default=None, description="The IP address of the secondary DNS server")
+ __properties: ClassVar[List[str]] = ["domain_name", "id", "name", "primary", "secondary"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of InternalDnsServers from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of InternalDnsServers from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "domain_name": obj.get("domain_name"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "primary": obj.get("primary"),
+ "secondary": obj.get("secondary")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/internal_dns_servers_list_response.py b/scm/deployment_services/models/internal_dns_servers_list_response.py
new file mode 100644
index 00000000..ddf6eced
--- /dev/null
+++ b/scm/deployment_services/models/internal_dns_servers_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InternalDNSServersListResponse(BaseModel):
+ """
+ InternalDNSServersListResponse
+ """ # noqa: E501
+ data: List[InternalDnsServers]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of InternalDNSServersListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of InternalDNSServersListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = InternalDnsServers.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [InternalDnsServers.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/locations.py b/scm/deployment_services/models/locations.py
new file mode 100644
index 00000000..f8148b12
--- /dev/null
+++ b/scm/deployment_services/models/locations.py
@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Locations(BaseModel):
+ """
+ Locations
+ """ # noqa: E501
+ aggregate_region: Optional[StrictStr] = None
+ continent: Optional[StrictStr] = Field(default=None, description="The continent in which the location exists")
+ display: Optional[StrictStr] = Field(default=None, description="The location as displayed in the Strata Cloud Manager portal")
+ latitude: Optional[Union[Annotated[float, Field(le=90, strict=True, ge=-90)], Annotated[int, Field(le=90, strict=True, ge=-90)]]] = Field(default=None, description="The latitudinal position of the location")
+ longitude: Optional[Union[Annotated[float, Field(le=180, strict=True, ge=-180)], Annotated[int, Field(le=180, strict=True, ge=-180)]]] = Field(default=None, description="The longitudinal position of the location")
+ region: Optional[StrictStr] = None
+ value: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["aggregate_region", "continent", "display", "latitude", "longitude", "region", "value"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Locations from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Locations from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "aggregate_region": obj.get("aggregate_region"),
+ "continent": obj.get("continent"),
+ "display": obj.get("display"),
+ "latitude": obj.get("latitude"),
+ "longitude": obj.get("longitude"),
+ "region": obj.get("region"),
+ "value": obj.get("value")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/remote_networks.py b/scm/deployment_services/models/remote_networks.py
new file mode 100644
index 00000000..71944216
--- /dev/null
+++ b/scm/deployment_services/models/remote_networks.py
@@ -0,0 +1,135 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner import RemoteNetworksEcmpTunnelsInner
+from scm.deployment_services.models.remote_networks_protocol import RemoteNetworksProtocol
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteNetworks(BaseModel):
+ """
+ RemoteNetworks
+ """ # noqa: E501
+ ecmp_load_balancing: Optional[StrictStr] = 'disable'
+ ecmp_tunnels: Optional[List[RemoteNetworksEcmpTunnelsInner]] = Field(default=None, description="ecmp_tunnels is required when ecmp_load_balancing is enable")
+ folder: StrictStr = Field(description="The folder that contains the remote network")
+ id: StrictStr = Field(description="The UUID of the remote network")
+ ipsec_tunnel: Optional[StrictStr] = Field(default=None, description="ipsec_tunnel is required when ecmp_load_balancing is disable")
+ license_type: Annotated[str, Field(min_length=1, strict=True)] = Field(description="New customer will only be on aggregate bandwidth licensing")
+ name: Annotated[str, Field(strict=True, max_length=63)] = Field(description="The name of the remote network")
+ protocol: Optional[RemoteNetworksProtocol] = None
+ region: Annotated[str, Field(min_length=1, strict=True)]
+ secondary_ipsec_tunnel: Optional[StrictStr] = Field(default=None, description="specify secondary ipsec_tunnel if needed")
+ spn_name: Optional[StrictStr] = Field(default=None, description="spn-name is needed when license_type is FWAAS-AGGREGATE")
+ subnets: Optional[List[StrictStr]] = None
+ __properties: ClassVar[List[str]] = ["ecmp_load_balancing", "ecmp_tunnels", "folder", "id", "ipsec_tunnel", "license_type", "name", "protocol", "region", "secondary_ipsec_tunnel", "spn_name", "subnets"]
+
+ @field_validator('ecmp_load_balancing')
+ def ecmp_load_balancing_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['enable', 'disable']):
+ raise ValueError("must be one of enum values ('enable', 'disable')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RemoteNetworks from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in ecmp_tunnels (list)
+ _items = []
+ if self.ecmp_tunnels:
+ for _item_ecmp_tunnels in self.ecmp_tunnels:
+ if _item_ecmp_tunnels:
+ _items.append(_item_ecmp_tunnels.to_dict())
+ _dict['ecmp_tunnels'] = _items
+ # override the default output from pydantic by calling `to_dict()` of protocol
+ if self.protocol:
+ _dict['protocol'] = self.protocol.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RemoteNetworks from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ecmp_load_balancing": obj.get("ecmp_load_balancing") if obj.get("ecmp_load_balancing") is not None else 'disable',
+ "ecmp_tunnels": [RemoteNetworksEcmpTunnelsInner.from_dict(_item) for _item in obj["ecmp_tunnels"]] if obj.get("ecmp_tunnels") is not None else None,
+ "folder": obj.get("folder") if obj.get("folder") is not None else 'Remote Networks',
+ "id": obj.get("id"),
+ "ipsec_tunnel": obj.get("ipsec_tunnel"),
+ "license_type": obj.get("license_type") if obj.get("license_type") is not None else 'FWAAS-AGGREGATE',
+ "name": obj.get("name"),
+ "protocol": RemoteNetworksProtocol.from_dict(obj["protocol"]) if obj.get("protocol") is not None else None,
+ "region": obj.get("region"),
+ "secondary_ipsec_tunnel": obj.get("secondary_ipsec_tunnel"),
+ "spn_name": obj.get("spn_name"),
+ "subnets": obj.get("subnets")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/remote_networks_ecmp_tunnels_inner.py b/scm/deployment_services/models/remote_networks_ecmp_tunnels_inner.py
new file mode 100644
index 00000000..cea7834b
--- /dev/null
+++ b/scm/deployment_services/models/remote_networks_ecmp_tunnels_inner.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.remote_networks_ecmp_tunnels_inner_protocol import RemoteNetworksEcmpTunnelsInnerProtocol
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteNetworksEcmpTunnelsInner(BaseModel):
+ """
+ RemoteNetworksEcmpTunnelsInner
+ """ # noqa: E501
+ ipsec_tunnel: StrictStr
+ name: StrictStr
+ protocol: RemoteNetworksEcmpTunnelsInnerProtocol
+ __properties: ClassVar[List[str]] = ["ipsec_tunnel", "name", "protocol"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RemoteNetworksEcmpTunnelsInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of protocol
+ if self.protocol:
+ _dict['protocol'] = self.protocol.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RemoteNetworksEcmpTunnelsInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ipsec_tunnel": obj.get("ipsec_tunnel"),
+ "name": obj.get("name"),
+ "protocol": RemoteNetworksEcmpTunnelsInnerProtocol.from_dict(obj["protocol"]) if obj.get("protocol") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/remote_networks_ecmp_tunnels_inner_protocol.py b/scm/deployment_services/models/remote_networks_ecmp_tunnels_inner_protocol.py
new file mode 100644
index 00000000..367e1ecc
--- /dev/null
+++ b/scm/deployment_services/models/remote_networks_ecmp_tunnels_inner_protocol.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.remote_networks_protocol_bgp import RemoteNetworksProtocolBgp
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteNetworksEcmpTunnelsInnerProtocol(BaseModel):
+ """
+ RemoteNetworksEcmpTunnelsInnerProtocol
+ """ # noqa: E501
+ bgp: Optional[RemoteNetworksProtocolBgp] = None
+ __properties: ClassVar[List[str]] = ["bgp"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RemoteNetworksEcmpTunnelsInnerProtocol from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of bgp
+ if self.bgp:
+ _dict['bgp'] = self.bgp.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RemoteNetworksEcmpTunnelsInnerProtocol from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "bgp": RemoteNetworksProtocolBgp.from_dict(obj["bgp"]) if obj.get("bgp") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/remote_networks_list_response.py b/scm/deployment_services/models/remote_networks_list_response.py
new file mode 100644
index 00000000..82a11c44
--- /dev/null
+++ b/scm/deployment_services/models/remote_networks_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteNetworksListResponse(BaseModel):
+ """
+ RemoteNetworksListResponse
+ """ # noqa: E501
+ data: List[RemoteNetworks]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RemoteNetworksListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RemoteNetworksListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = RemoteNetworks.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [RemoteNetworks.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/remote_networks_protocol.py b/scm/deployment_services/models/remote_networks_protocol.py
new file mode 100644
index 00000000..4aab82f4
--- /dev/null
+++ b/scm/deployment_services/models/remote_networks_protocol.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.remote_networks_protocol_bgp import RemoteNetworksProtocolBgp
+from scm.deployment_services.models.remote_networks_protocol_bgp_peer import RemoteNetworksProtocolBgpPeer
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteNetworksProtocol(BaseModel):
+ """
+ setup the protocol when ecmp_load_balancing is disable
+ """ # noqa: E501
+ bgp: Optional[RemoteNetworksProtocolBgp] = None
+ bgp_peer: Optional[RemoteNetworksProtocolBgpPeer] = None
+ __properties: ClassVar[List[str]] = ["bgp", "bgp_peer"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RemoteNetworksProtocol from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of bgp
+ if self.bgp:
+ _dict['bgp'] = self.bgp.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of bgp_peer
+ if self.bgp_peer:
+ _dict['bgp_peer'] = self.bgp_peer.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RemoteNetworksProtocol from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "bgp": RemoteNetworksProtocolBgp.from_dict(obj["bgp"]) if obj.get("bgp") is not None else None,
+ "bgp_peer": RemoteNetworksProtocolBgpPeer.from_dict(obj["bgp_peer"]) if obj.get("bgp_peer") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/remote_networks_protocol_bgp.py b/scm/deployment_services/models/remote_networks_protocol_bgp.py
new file mode 100644
index 00000000..626c43b0
--- /dev/null
+++ b/scm/deployment_services/models/remote_networks_protocol_bgp.py
@@ -0,0 +1,114 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteNetworksProtocolBgp(BaseModel):
+ """
+ RemoteNetworksProtocolBgp
+ """ # noqa: E501
+ do_not_export_routes: Optional[StrictBool] = Field(default=None, description="Do not export routes?")
+ enable: Optional[StrictBool] = Field(default=None, description="Enable BGP peering?")
+ local_ip_address: Optional[StrictStr] = Field(default=None, description="Local peer IP address")
+ originate_default_route: Optional[StrictBool] = Field(default=None, description="Originate default route?")
+ peer_as: Optional[StrictStr] = Field(default=None, description="BGP peer ASN")
+ peer_ip_address: Optional[StrictStr] = Field(default=None, description="Remote peer IP address")
+ peering_type: Optional[StrictStr] = Field(default=None, description="Route exchange types")
+ secret: Optional[SecretStr] = Field(default=None, description="BGP peering secret")
+ summarize_mobile_user_routes: Optional[StrictBool] = Field(default=None, description="Summarize mobile user routes?")
+ __properties: ClassVar[List[str]] = ["do_not_export_routes", "enable", "local_ip_address", "originate_default_route", "peer_as", "peer_ip_address", "peering_type", "secret", "summarize_mobile_user_routes"]
+
+ @field_validator('peering_type')
+ def peering_type_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['exchange-v4-over-v4', 'exchange-v4-v6-over-v4', 'exchange-v4-over-v4-v6-over-v6', 'exchange-v6-over-v6']):
+ raise ValueError("must be one of enum values ('exchange-v4-over-v4', 'exchange-v4-v6-over-v4', 'exchange-v4-over-v4-v6-over-v6', 'exchange-v6-over-v6')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RemoteNetworksProtocolBgp from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RemoteNetworksProtocolBgp from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "do_not_export_routes": obj.get("do_not_export_routes"),
+ "enable": obj.get("enable"),
+ "local_ip_address": obj.get("local_ip_address"),
+ "originate_default_route": obj.get("originate_default_route"),
+ "peer_as": obj.get("peer_as"),
+ "peer_ip_address": obj.get("peer_ip_address"),
+ "peering_type": obj.get("peering_type"),
+ "secret": obj.get("secret"),
+ "summarize_mobile_user_routes": obj.get("summarize_mobile_user_routes")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/remote_networks_protocol_bgp_peer.py b/scm/deployment_services/models/remote_networks_protocol_bgp_peer.py
new file mode 100644
index 00000000..d1f0c975
--- /dev/null
+++ b/scm/deployment_services/models/remote_networks_protocol_bgp_peer.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RemoteNetworksProtocolBgpPeer(BaseModel):
+ """
+ secondary bgp routing as bgp_peer
+ """ # noqa: E501
+ local_ip_address: Optional[StrictStr] = Field(default=None, description="Local peer IP address (secondary WAN)")
+ peer_ip_address: Optional[StrictStr] = Field(default=None, description="Remote peer IP address (secondary WAN)")
+ same_as_primary: Optional[StrictBool] = Field(default=None, description="Same peer IP address as primary WAN")
+ secret: Optional[SecretStr] = Field(default=None, description="BGP peering secret (secondary WAN)")
+ __properties: ClassVar[List[str]] = ["local_ip_address", "peer_ip_address", "same_as_primary", "secret"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RemoteNetworksProtocolBgpPeer from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RemoteNetworksProtocolBgpPeer from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "local_ip_address": obj.get("local_ip_address"),
+ "peer_ip_address": obj.get("peer_ip_address"),
+ "same_as_primary": obj.get("same_as_primary"),
+ "secret": obj.get("secret")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connection_groups.py b/scm/deployment_services/models/service_connection_groups.py
new file mode 100644
index 00000000..a68ae222
--- /dev/null
+++ b/scm/deployment_services/models/service_connection_groups.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnectionGroups(BaseModel):
+ """
+ ServiceConnectionGroups
+ """ # noqa: E501
+ disable_snat: Optional[StrictBool] = None
+ id: StrictStr = Field(description="The UUID of the service connection group")
+ name: StrictStr
+ pbf_only: Optional[StrictBool] = None
+ target: List[StrictStr]
+ __properties: ClassVar[List[str]] = ["disable_snat", "id", "name", "pbf_only", "target"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnectionGroups from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnectionGroups from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "disable_snat": obj.get("disable_snat"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "pbf_only": obj.get("pbf_only"),
+ "target": obj.get("target")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connection_groups_list_response.py b/scm/deployment_services/models/service_connection_groups_list_response.py
new file mode 100644
index 00000000..0b41efce
--- /dev/null
+++ b/scm/deployment_services/models/service_connection_groups_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnectionGroupsListResponse(BaseModel):
+ """
+ ServiceConnectionGroupsListResponse
+ """ # noqa: E501
+ data: List[ServiceConnectionGroups]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnectionGroupsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnectionGroupsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = ServiceConnectionGroups.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [ServiceConnectionGroups.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connections.py b/scm/deployment_services/models/service_connections.py
new file mode 100644
index 00000000..700634c0
--- /dev/null
+++ b/scm/deployment_services/models/service_connections.py
@@ -0,0 +1,148 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.service_connections_bgp_peer import ServiceConnectionsBgpPeer
+from scm.deployment_services.models.service_connections_protocol import ServiceConnectionsProtocol
+from scm.deployment_services.models.service_connections_qos import ServiceConnectionsQos
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnections(BaseModel):
+ """
+ ServiceConnections
+ """ # noqa: E501
+ backup_sc: Optional[StrictStr] = Field(default=None, alias="backup_SC")
+ bgp_peer: Optional[ServiceConnectionsBgpPeer] = None
+ id: StrictStr = Field(description="The UUID of the service connection")
+ ipsec_tunnel: StrictStr
+ name: StrictStr = Field(description="The name of the service connection")
+ nat_pool: Optional[StrictStr] = None
+ no_export_community: Optional[StrictStr] = None
+ onboarding_type: Optional[StrictStr] = 'classic'
+ protocol: Optional[ServiceConnectionsProtocol] = None
+ qos: Optional[ServiceConnectionsQos] = None
+ region: StrictStr
+ secondary_ipsec_tunnel: Optional[StrictStr] = None
+ source_nat: Optional[StrictBool] = None
+ subnets: Optional[List[StrictStr]] = None
+ __properties: ClassVar[List[str]] = ["backup_SC", "bgp_peer", "id", "ipsec_tunnel", "name", "nat_pool", "no_export_community", "onboarding_type", "protocol", "qos", "region", "secondary_ipsec_tunnel", "source_nat", "subnets"]
+
+ @field_validator('no_export_community')
+ def no_export_community_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['Disabled', 'Enabled-In', 'Enabled-Out', 'Enabled-Both']):
+ raise ValueError("must be one of enum values ('Disabled', 'Enabled-In', 'Enabled-Out', 'Enabled-Both')")
+ return value
+
+ @field_validator('onboarding_type')
+ def onboarding_type_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['classic']):
+ raise ValueError("must be one of enum values ('classic')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnections from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of bgp_peer
+ if self.bgp_peer:
+ _dict['bgp_peer'] = self.bgp_peer.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of protocol
+ if self.protocol:
+ _dict['protocol'] = self.protocol.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of qos
+ if self.qos:
+ _dict['qos'] = self.qos.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnections from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "backup_SC": obj.get("backup_SC"),
+ "bgp_peer": ServiceConnectionsBgpPeer.from_dict(obj["bgp_peer"]) if obj.get("bgp_peer") is not None else None,
+ "id": obj.get("id"),
+ "ipsec_tunnel": obj.get("ipsec_tunnel"),
+ "name": obj.get("name"),
+ "nat_pool": obj.get("nat_pool"),
+ "no_export_community": obj.get("no_export_community"),
+ "onboarding_type": obj.get("onboarding_type") if obj.get("onboarding_type") is not None else 'classic',
+ "protocol": ServiceConnectionsProtocol.from_dict(obj["protocol"]) if obj.get("protocol") is not None else None,
+ "qos": ServiceConnectionsQos.from_dict(obj["qos"]) if obj.get("qos") is not None else None,
+ "region": obj.get("region"),
+ "secondary_ipsec_tunnel": obj.get("secondary_ipsec_tunnel"),
+ "source_nat": obj.get("source_nat"),
+ "subnets": obj.get("subnets")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connections_bgp_peer.py b/scm/deployment_services/models/service_connections_bgp_peer.py
new file mode 100644
index 00000000..d993ebb5
--- /dev/null
+++ b/scm/deployment_services/models/service_connections_bgp_peer.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, SecretStr, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnectionsBgpPeer(BaseModel):
+ """
+ ServiceConnectionsBgpPeer
+ """ # noqa: E501
+ local_ip_address: Optional[StrictStr] = None
+ local_ipv6_address: Optional[StrictStr] = None
+ peer_ip_address: Optional[StrictStr] = None
+ peer_ipv6_address: Optional[StrictStr] = None
+ secret: Optional[SecretStr] = None
+ __properties: ClassVar[List[str]] = ["local_ip_address", "local_ipv6_address", "peer_ip_address", "peer_ipv6_address", "secret"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsBgpPeer from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsBgpPeer from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "local_ip_address": obj.get("local_ip_address"),
+ "local_ipv6_address": obj.get("local_ipv6_address"),
+ "peer_ip_address": obj.get("peer_ip_address"),
+ "peer_ipv6_address": obj.get("peer_ipv6_address"),
+ "secret": obj.get("secret")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connections_list_response.py b/scm/deployment_services/models/service_connections_list_response.py
new file mode 100644
index 00000000..d4477de9
--- /dev/null
+++ b/scm/deployment_services/models/service_connections_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.service_connections import ServiceConnections
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnectionsListResponse(BaseModel):
+ """
+ ServiceConnectionsListResponse
+ """ # noqa: E501
+ data: List[ServiceConnections]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = ServiceConnections.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [ServiceConnections.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connections_protocol.py b/scm/deployment_services/models/service_connections_protocol.py
new file mode 100644
index 00000000..d65a4e4a
--- /dev/null
+++ b/scm/deployment_services/models/service_connections_protocol.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.service_connections_protocol_bgp import ServiceConnectionsProtocolBgp
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnectionsProtocol(BaseModel):
+ """
+ ServiceConnectionsProtocol
+ """ # noqa: E501
+ bgp: Optional[ServiceConnectionsProtocolBgp] = None
+ __properties: ClassVar[List[str]] = ["bgp"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsProtocol from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of bgp
+ if self.bgp:
+ _dict['bgp'] = self.bgp.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsProtocol from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "bgp": ServiceConnectionsProtocolBgp.from_dict(obj["bgp"]) if obj.get("bgp") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connections_protocol_bgp.py b/scm/deployment_services/models/service_connections_protocol_bgp.py
new file mode 100644
index 00000000..6fcf5f9a
--- /dev/null
+++ b/scm/deployment_services/models/service_connections_protocol_bgp.py
@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, SecretStr, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnectionsProtocolBgp(BaseModel):
+ """
+ ServiceConnectionsProtocolBgp
+ """ # noqa: E501
+ do_not_export_routes: Optional[StrictBool] = None
+ enable: Optional[StrictBool] = None
+ fast_failover: Optional[StrictBool] = None
+ local_ip_address: Optional[StrictStr] = None
+ originate_default_route: Optional[StrictBool] = None
+ peer_as: StrictStr
+ peer_ip_address: Optional[StrictStr] = None
+ secret: Optional[SecretStr] = None
+ summarize_mobile_user_routes: Optional[StrictBool] = None
+ __properties: ClassVar[List[str]] = ["do_not_export_routes", "enable", "fast_failover", "local_ip_address", "originate_default_route", "peer_as", "peer_ip_address", "secret", "summarize_mobile_user_routes"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsProtocolBgp from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsProtocolBgp from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "do_not_export_routes": obj.get("do_not_export_routes"),
+ "enable": obj.get("enable"),
+ "fast_failover": obj.get("fast_failover"),
+ "local_ip_address": obj.get("local_ip_address"),
+ "originate_default_route": obj.get("originate_default_route"),
+ "peer_as": obj.get("peer_as"),
+ "peer_ip_address": obj.get("peer_ip_address"),
+ "secret": obj.get("secret"),
+ "summarize_mobile_user_routes": obj.get("summarize_mobile_user_routes")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/service_connections_qos.py b/scm/deployment_services/models/service_connections_qos.py
new file mode 100644
index 00000000..f7940a32
--- /dev/null
+++ b/scm/deployment_services/models/service_connections_qos.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceConnectionsQos(BaseModel):
+ """
+ ServiceConnectionsQos
+ """ # noqa: E501
+ enable: Optional[StrictBool] = None
+ qos_profile: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["enable", "qos_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsQos from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceConnectionsQos from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "enable": obj.get("enable"),
+ "qos_profile": obj.get("qos_profile")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/shared_infrastructure_settings.py b/scm/deployment_services/models/shared_infrastructure_settings.py
new file mode 100644
index 00000000..c1334602
--- /dev/null
+++ b/scm/deployment_services/models/shared_infrastructure_settings.py
@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_application_blocks import EditSharedInfrastructureSettingsConnectorApplicationBlocks
+from scm.deployment_services.models.edit_shared_infrastructure_settings_connector_connector_blocks import EditSharedInfrastructureSettingsConnectorConnectorBlocks
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SharedInfrastructureSettings(BaseModel):
+ """
+ SharedInfrastructureSettings
+ """ # noqa: E501
+ api_key: Optional[StrictStr] = None
+ captive_portal_redirect_ip_address: Optional[StrictStr] = None
+ connector_application_blocks: Optional[EditSharedInfrastructureSettingsConnectorApplicationBlocks] = Field(default=None, alias="connector-application-blocks")
+ connector_connector_blocks: Optional[EditSharedInfrastructureSettingsConnectorConnectorBlocks] = Field(default=None, alias="connector-connector-blocks")
+ egress_ip_notification_url: Optional[StrictStr] = None
+ folder: Optional[StrictStr] = Field(default='Shared', description="The folder containing the shared infrastructure settings")
+ infra_bgp_as: Optional[StrictStr] = None
+ infrastructure_subnet: Optional[StrictStr] = None
+ infrastructure_subnet_ipv6: Optional[StrictStr] = None
+ ipv6: Optional[StrictBool] = None
+ loopback_ips: Optional[List[StrictStr]] = None
+ tunnel_monitor_ip_address: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["api_key", "captive_portal_redirect_ip_address", "connector-application-blocks", "connector-connector-blocks", "egress_ip_notification_url", "folder", "infra_bgp_as", "infrastructure_subnet", "infrastructure_subnet_ipv6", "ipv6", "loopback_ips", "tunnel_monitor_ip_address"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SharedInfrastructureSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "folder",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of connector_application_blocks
+ if self.connector_application_blocks:
+ _dict['connector-application-blocks'] = self.connector_application_blocks.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of connector_connector_blocks
+ if self.connector_connector_blocks:
+ _dict['connector-connector-blocks'] = self.connector_connector_blocks.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SharedInfrastructureSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "api_key": obj.get("api_key"),
+ "captive_portal_redirect_ip_address": obj.get("captive_portal_redirect_ip_address"),
+ "connector-application-blocks": EditSharedInfrastructureSettingsConnectorApplicationBlocks.from_dict(obj["connector-application-blocks"]) if obj.get("connector-application-blocks") is not None else None,
+ "connector-connector-blocks": EditSharedInfrastructureSettingsConnectorConnectorBlocks.from_dict(obj["connector-connector-blocks"]) if obj.get("connector-connector-blocks") is not None else None,
+ "egress_ip_notification_url": obj.get("egress_ip_notification_url"),
+ "folder": obj.get("folder") if obj.get("folder") is not None else 'Shared',
+ "infra_bgp_as": obj.get("infra_bgp_as"),
+ "infrastructure_subnet": obj.get("infrastructure_subnet"),
+ "infrastructure_subnet_ipv6": obj.get("infrastructure_subnet_ipv6"),
+ "ipv6": obj.get("ipv6"),
+ "loopback_ips": obj.get("loopback_ips"),
+ "tunnel_monitor_ip_address": obj.get("tunnel_monitor_ip_address")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/sites.py b/scm/deployment_services/models/sites.py
new file mode 100644
index 00000000..057d0dec
--- /dev/null
+++ b/scm/deployment_services/models/sites.py
@@ -0,0 +1,149 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.deployment_services.models.sites_members_inner import SitesMembersInner
+from scm.deployment_services.models.sites_qos import SitesQos
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Sites(BaseModel):
+ """
+ Sites
+ """ # noqa: E501
+ address_line_1: Optional[StrictStr] = Field(default=None, description="The address in which the site exists")
+ address_line_2: Optional[StrictStr] = Field(default=None, description="The address in which the site exists (continued)")
+ city: Optional[StrictStr] = Field(default=None, description="The city in which the site exists")
+ country: Optional[StrictStr] = Field(default=None, description="The country in which the site exists")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the site")
+ latitude: Optional[StrictStr] = Field(default=None, description="The latitude coordinate for the site")
+ license_type: Optional[Annotated[str, Field(strict=True, max_length=63)]] = Field(default=None, description="The license type of the site")
+ longitude: Optional[StrictStr] = Field(default=None, description="The longitude coordinate for the site")
+ members: Optional[List[SitesMembersInner]] = None
+ name: Annotated[str, Field(strict=True, max_length=63)] = Field(description="The name of the site")
+ qos: Optional[SitesQos] = None
+ state: Optional[StrictStr] = Field(default=None, description="The state in which the site exists")
+ type: Optional[StrictStr] = Field(default=None, description="The site type")
+ zip_code: Optional[StrictStr] = Field(default=None, description="The postal code in which the site exists")
+ __properties: ClassVar[List[str]] = ["address_line_1", "address_line_2", "city", "country", "id", "latitude", "license_type", "longitude", "members", "name", "qos", "state", "type", "zip_code"]
+
+ @field_validator('license_type')
+ def license_type_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['FWAAS-SITE-25Mbps', 'FWAAS-SITE-50Mbps', 'FWAAS-SITE-250Mbps', 'FWAAS-SITE-1000Mbps', 'FWAAS-SITE-2500Mbps']):
+ raise ValueError("must be one of enum values ('FWAAS-SITE-25Mbps', 'FWAAS-SITE-50Mbps', 'FWAAS-SITE-250Mbps', 'FWAAS-SITE-1000Mbps', 'FWAAS-SITE-2500Mbps')")
+ return value
+
+ @field_validator('type')
+ def type_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['prisma-sdwan', 'third-party-branch', 'third-party-discovered']):
+ raise ValueError("must be one of enum values ('prisma-sdwan', 'third-party-branch', 'third-party-discovered')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of Sites from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in members (list)
+ _items = []
+ if self.members:
+ for _item_members in self.members:
+ if _item_members:
+ _items.append(_item_members.to_dict())
+ _dict['members'] = _items
+ # override the default output from pydantic by calling `to_dict()` of qos
+ if self.qos:
+ _dict['qos'] = self.qos.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of Sites from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "address_line_1": obj.get("address_line_1"),
+ "address_line_2": obj.get("address_line_2"),
+ "city": obj.get("city"),
+ "country": obj.get("country"),
+ "id": obj.get("id"),
+ "latitude": obj.get("latitude"),
+ "license_type": obj.get("license_type"),
+ "longitude": obj.get("longitude"),
+ "members": [SitesMembersInner.from_dict(_item) for _item in obj["members"]] if obj.get("members") is not None else None,
+ "name": obj.get("name"),
+ "qos": SitesQos.from_dict(obj["qos"]) if obj.get("qos") is not None else None,
+ "state": obj.get("state"),
+ "type": obj.get("type"),
+ "zip_code": obj.get("zip_code")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/sites_list_response.py b/scm/deployment_services/models/sites_list_response.py
new file mode 100644
index 00000000..5cb20b6d
--- /dev/null
+++ b/scm/deployment_services/models/sites_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.sites import Sites
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SitesListResponse(BaseModel):
+ """
+ SitesListResponse
+ """ # noqa: E501
+ data: List[Sites]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SitesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SitesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = Sites.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [Sites.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/sites_members_inner.py b/scm/deployment_services/models/sites_members_inner.py
new file mode 100644
index 00000000..f091386f
--- /dev/null
+++ b/scm/deployment_services/models/sites_members_inner.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SitesMembersInner(BaseModel):
+ """
+ SitesMembersInner
+ """ # noqa: E501
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the remote network")
+ mode: StrictStr = Field(description="The mode of the remote network")
+ name: StrictStr = Field(description="The member name")
+ remote_network: Optional[StrictStr] = Field(default=None, description="The remote network name")
+ __properties: ClassVar[List[str]] = ["id", "mode", "name", "remote_network"]
+
+ @field_validator('mode')
+ def mode_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['active', 'backup']):
+ raise ValueError("must be one of enum values ('active', 'backup')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SitesMembersInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SitesMembersInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "id": obj.get("id"),
+ "mode": obj.get("mode"),
+ "name": obj.get("name"),
+ "remote_network": obj.get("remote_network")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/sites_qos.py b/scm/deployment_services/models/sites_qos.py
new file mode 100644
index 00000000..c0dfee5a
--- /dev/null
+++ b/scm/deployment_services/models/sites_qos.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SitesQos(BaseModel):
+ """
+ SitesQos
+ """ # noqa: E501
+ backup_cir: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The backup CIR in Mbps. This is distributed equally for all tunnels in the site.")
+ cir: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The CIR in Mbps. This is distributed equally for all tunnels in the site.")
+ profile: Optional[StrictStr] = Field(default=None, description="The name of the site QoS profile")
+ __properties: ClassVar[List[str]] = ["backup_cir", "cir", "profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SitesQos from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SitesQos from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "backup_cir": obj.get("backup_cir"),
+ "cir": obj.get("cir"),
+ "profile": obj.get("profile")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/traffic_steering_rules.py b/scm/deployment_services/models/traffic_steering_rules.py
new file mode 100644
index 00000000..9039a9b3
--- /dev/null
+++ b/scm/deployment_services/models/traffic_steering_rules.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.traffic_steering_rules_action import TrafficSteeringRulesAction
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrafficSteeringRules(BaseModel):
+ """
+ TrafficSteeringRules
+ """ # noqa: E501
+ action: Optional[TrafficSteeringRulesAction] = None
+ category: Optional[List[StrictStr]] = None
+ destination: Optional[List[StrictStr]] = None
+ folder: Optional[StrictStr] = Field(default='Service Connections', description="The folder containing the traffic steering rule")
+ id: StrictStr = Field(description="The UUID of the traffic steering rule")
+ name: StrictStr
+ service: List[StrictStr]
+ source: List[StrictStr]
+ source_user: Optional[List[StrictStr]] = None
+ __properties: ClassVar[List[str]] = ["action", "category", "destination", "folder", "id", "name", "service", "source", "source_user"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRules from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of action
+ if self.action:
+ _dict['action'] = self.action.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRules from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": TrafficSteeringRulesAction.from_dict(obj["action"]) if obj.get("action") is not None else None,
+ "category": obj.get("category"),
+ "destination": obj.get("destination"),
+ "folder": obj.get("folder") if obj.get("folder") is not None else 'Service Connections',
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "service": obj.get("service"),
+ "source": obj.get("source"),
+ "source_user": obj.get("source_user")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/traffic_steering_rules_action.py b/scm/deployment_services/models/traffic_steering_rules_action.py
new file mode 100644
index 00000000..147d7b1a
--- /dev/null
+++ b/scm/deployment_services/models/traffic_steering_rules_action.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.traffic_steering_rules_action_forward import TrafficSteeringRulesActionForward
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrafficSteeringRulesAction(BaseModel):
+ """
+ TrafficSteeringRulesAction
+ """ # noqa: E501
+ forward: Optional[TrafficSteeringRulesActionForward] = None
+ __properties: ClassVar[List[str]] = ["forward"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesAction from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of forward
+ if self.forward:
+ _dict['forward'] = self.forward.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesAction from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "forward": TrafficSteeringRulesActionForward.from_dict(obj["forward"]) if obj.get("forward") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/traffic_steering_rules_action_forward.py b/scm/deployment_services/models/traffic_steering_rules_action_forward.py
new file mode 100644
index 00000000..fc499e0d
--- /dev/null
+++ b/scm/deployment_services/models/traffic_steering_rules_action_forward.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.deployment_services.models.traffic_steering_rules_action_forward_forward import TrafficSteeringRulesActionForwardForward
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrafficSteeringRulesActionForward(BaseModel):
+ """
+ TrafficSteeringRulesActionForward
+ """ # noqa: E501
+ forward: Optional[TrafficSteeringRulesActionForwardForward] = None
+ no_pbf: Optional[Dict[str, Any]] = Field(default=None, alias="no-pbf")
+ __properties: ClassVar[List[str]] = ["forward", "no-pbf"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesActionForward from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of forward
+ if self.forward:
+ _dict['forward'] = self.forward.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesActionForward from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "forward": TrafficSteeringRulesActionForwardForward.from_dict(obj["forward"]) if obj.get("forward") is not None else None,
+ "no-pbf": obj.get("no-pbf")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/traffic_steering_rules_action_forward_forward.py b/scm/deployment_services/models/traffic_steering_rules_action_forward_forward.py
new file mode 100644
index 00000000..5cc16c16
--- /dev/null
+++ b/scm/deployment_services/models/traffic_steering_rules_action_forward_forward.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrafficSteeringRulesActionForwardForward(BaseModel):
+ """
+ TrafficSteeringRulesActionForwardForward
+ """ # noqa: E501
+ target: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["target"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesActionForwardForward from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesActionForwardForward from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "target": obj.get("target")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/models/traffic_steering_rules_list_response.py b/scm/deployment_services/models/traffic_steering_rules_list_response.py
new file mode 100644
index 00000000..972d8a63
--- /dev/null
+++ b/scm/deployment_services/models/traffic_steering_rules_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrafficSteeringRulesListResponse(BaseModel):
+ """
+ TrafficSteeringRulesListResponse
+ """ # noqa: E501
+ data: List[TrafficSteeringRules]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrafficSteeringRulesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = TrafficSteeringRules.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [TrafficSteeringRules.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/deployment_services/rest.py b/scm/deployment_services/rest.py
new file mode 100644
index 00000000..bc8629d7
--- /dev/null
+++ b/scm/deployment_services/rest.py
@@ -0,0 +1,258 @@
+# coding: utf-8
+
+"""
+ Network Deployment
+
+ These APIs are used for defining and managing Prisma Access Remote Network and Service Connection configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import io
+import json
+import re
+import ssl
+
+import urllib3
+
+from scm.deployment_services.exceptions import ApiException, ApiValueError
+
+SUPPORTED_SOCKS_PROXIES = {"socks5", "socks5h", "socks4", "socks4a"}
+RESTResponseType = urllib3.HTTPResponse
+
+
+def is_socks_proxy_url(url):
+ if url is None:
+ return False
+ split_section = url.split("://")
+ if len(split_section) < 2:
+ return False
+ else:
+ return split_section[0].lower() in SUPPORTED_SOCKS_PROXIES
+
+
+class RESTResponse(io.IOBase):
+
+ def __init__(self, resp) -> None:
+ self.response = resp
+ self.status = resp.status
+ self.reason = resp.reason
+ self.data = None
+
+ def read(self):
+ if self.data is None:
+ self.data = self.response.data
+ return self.data
+
+ def getheaders(self):
+ """Returns a dictionary of the response headers."""
+ return self.response.headers
+
+ def getheader(self, name, default=None):
+ """Returns a given response header."""
+ return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+ def __init__(self, configuration) -> None:
+ # urllib3.PoolManager will pass all kw parameters to connectionpool
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501
+ # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501
+
+ # cert_reqs
+ if configuration.verify_ssl:
+ cert_reqs = ssl.CERT_REQUIRED
+ else:
+ cert_reqs = ssl.CERT_NONE
+
+ pool_args = {
+ "cert_reqs": cert_reqs,
+ "ca_certs": configuration.ssl_ca_cert,
+ "cert_file": configuration.cert_file,
+ "key_file": configuration.key_file,
+ }
+ if configuration.assert_hostname is not None:
+ pool_args['assert_hostname'] = (
+ configuration.assert_hostname
+ )
+
+ if configuration.retries is not None:
+ pool_args['retries'] = configuration.retries
+
+ if configuration.tls_server_name:
+ pool_args['server_hostname'] = configuration.tls_server_name
+
+
+ if configuration.socket_options is not None:
+ pool_args['socket_options'] = configuration.socket_options
+
+ if configuration.connection_pool_maxsize is not None:
+ pool_args['maxsize'] = configuration.connection_pool_maxsize
+
+ # https pool manager
+ self.pool_manager: urllib3.PoolManager
+
+ if configuration.proxy:
+ if is_socks_proxy_url(configuration.proxy):
+ from urllib3.contrib.socks import SOCKSProxyManager
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["headers"] = configuration.proxy_headers
+ self.pool_manager = SOCKSProxyManager(**pool_args)
+ else:
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["proxy_headers"] = configuration.proxy_headers
+ self.pool_manager = urllib3.ProxyManager(**pool_args)
+ else:
+ self.pool_manager = urllib3.PoolManager(**pool_args)
+
+ def request(
+ self,
+ method,
+ url,
+ headers=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ):
+ """Perform requests.
+
+ :param method: http request method
+ :param url: http request url
+ :param headers: http request headers
+ :param body: request json body, for `application/json`
+ :param post_params: request post parameters,
+ `application/x-www-form-urlencoded`
+ and `multipart/form-data`
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ """
+ method = method.upper()
+ assert method in [
+ 'GET',
+ 'HEAD',
+ 'DELETE',
+ 'POST',
+ 'PUT',
+ 'PATCH',
+ 'OPTIONS'
+ ]
+
+ if post_params and body:
+ raise ApiValueError(
+ "body parameter cannot be used with post_params parameter."
+ )
+
+ post_params = post_params or {}
+ headers = headers or {}
+
+ timeout = None
+ if _request_timeout:
+ if isinstance(_request_timeout, (int, float)):
+ timeout = urllib3.Timeout(total=_request_timeout)
+ elif (
+ isinstance(_request_timeout, tuple)
+ and len(_request_timeout) == 2
+ ):
+ timeout = urllib3.Timeout(
+ connect=_request_timeout[0],
+ read=_request_timeout[1]
+ )
+
+ try:
+ # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+ if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+
+ # no content type provided or payload is json
+ content_type = headers.get('Content-Type')
+ if (
+ not content_type
+ or re.search('json', content_type, re.IGNORECASE)
+ ):
+ request_body = None
+ if body is not None:
+ request_body = json.dumps(body)
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'application/x-www-form-urlencoded':
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=False,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'multipart/form-data':
+ # must del headers['Content-Type'], or the correct
+ # Content-Type which generated by urllib3 will be
+ # overwritten.
+ del headers['Content-Type']
+ # Ensures that dict objects are serialized
+ post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a,b) for a, b in post_params]
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=True,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ # Pass a `string` parameter directly in the body to support
+ # other content types than JSON when `body` argument is
+ # provided in serialized form.
+ elif isinstance(body, str) or isinstance(body, bytes):
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif headers['Content-Type'].startswith('text/') and isinstance(body, bool):
+ request_body = "true" if body else "false"
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ preload_content=False,
+ timeout=timeout,
+ headers=headers)
+ else:
+ # Cannot generate the request from given parameters
+ msg = """Cannot prepare a request message for provided
+ arguments. Please check that your arguments match
+ declared content type."""
+ raise ApiException(status=0, reason=msg)
+ # For `GET`, `HEAD`
+ else:
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields={},
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ except urllib3.exceptions.SSLError as e:
+ msg = "\n".join([type(e).__name__, str(e)])
+ raise ApiException(status=0, reason=msg)
+
+ return RESTResponse(r)
diff --git a/scm/deployment_services/tests/__init__.py b/scm/deployment_services/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/scm/deployment_services/tests/api_application_defaults_test.py b/scm/deployment_services/tests/api_application_defaults_test.py
new file mode 100644
index 00000000..678fcd04
--- /dev/null
+++ b/scm/deployment_services/tests/api_application_defaults_test.py
@@ -0,0 +1,31 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def application_defaults_api(client):
+ return client.deployment_services.ApplicationDefaultsApi(client.deployment_services.api_client)
+
+
+def test_create_application_defaults(application_defaults_api):
+ """
+ Test creating/enabling application defaults (idempotent POST /enable operation).
+ This is safe to call repeatedly.
+ Equivalent to Go: Test_deployment_services_ApplicationDefaultsAPIService_Create
+ """
+ # This is an idempotent enable operation - no payload, no response body
+ application_defaults_api.create_application_defaults()
+ logger.info(f"Successfully created/enabled application defaults")
diff --git a/scm/deployment_services/tests/api_bandwidth_allocations_test.py b/scm/deployment_services/tests/api_bandwidth_allocations_test.py
new file mode 100644
index 00000000..14ed2ee0
--- /dev/null
+++ b/scm/deployment_services/tests/api_bandwidth_allocations_test.py
@@ -0,0 +1,65 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.deployment_services.models.bandwidth_allocations import BandwidthAllocations
+from scm.test_helpers import perform
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def bandwidth_allocations_api(client):
+ return client.deployment_services.BandwidthAllocationsApi(client.deployment_services.api_client)
+
+
+def test_create_bandwidth_allocation(bandwidth_allocations_api):
+ """
+ Test creating a bandwidth allocation.
+ Equivalent to Go: Test_deployment_services_BandwidthAllocationsAPIService_Create
+ """
+ test_name = f"test-bw-alloc-{uuid.uuid4().hex[:6]}"
+
+ payload = BandwidthAllocations(
+ name=test_name,
+ allocated_bandwidth=100,
+ )
+
+ # BandwidthAllocations API returns 200, not 201
+ created_obj = perform(
+ bandwidth_allocations_api.create_bandwidth_allocations_with_http_info,
+ response_type=BandwidthAllocations,
+ bandwidth_allocations=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.name == test_name
+ assert created_obj.allocated_bandwidth == 100
+ logger.info(f"Created bandwidth allocation: {created_obj.name}")
+
+ # Cleanup - delete requires spn_name_list, best-effort
+ try:
+ bandwidth_allocations_api.delete_bandwidth_allocations(
+ name=test_name,
+ spn_name_list="",
+ )
+ logger.info(f"Cleaned up: {test_name}")
+ except Exception as e:
+ logger.warning(f"Cleanup skipped (delete requires spn_name_list context): {e}")
+
+
+def test_list_bandwidth_allocations(bandwidth_allocations_api):
+ """Test listing Bandwidth Allocations."""
+ response = bandwidth_allocations_api.list_bandwidth_allocations()
+ assert response is not None
+ logger.info(f"Listed Bandwidth Allocations successfully")
diff --git a/scm/deployment_services/tests/api_bgp_routing_test.py b/scm/deployment_services/tests/api_bgp_routing_test.py
new file mode 100644
index 00000000..8372d672
--- /dev/null
+++ b/scm/deployment_services/tests/api_bgp_routing_test.py
@@ -0,0 +1,36 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def bgp_routing_api(client):
+ return client.deployment_services.BGPRoutingApi(client.deployment_services.api_client)
+
+
+def test_get_bgp_routing(bgp_routing_api):
+ """Test getting BGP Routing settings (singleton resource)."""
+ response = bgp_routing_api.get_bgp_routing()
+ assert response is not None
+ logger.info(f"Got BGP Routing settings successfully")
+
+
+def test_update_bgp_routing(bgp_routing_api):
+ """No-op update: get existing BGP Routing settings and update with same data."""
+ existing = bgp_routing_api.get_bgp_routing()
+ assert existing is not None
+ updated = bgp_routing_api.update_bgp_routing(bgp_routing=existing)
+ assert updated is not None
+ logger.info(f"Updated BGP Routing settings (no-op) successfully")
diff --git a/scm/deployment_services/tests/api_internal_dns_servers_test.py b/scm/deployment_services/tests/api_internal_dns_servers_test.py
new file mode 100644
index 00000000..9d563164
--- /dev/null
+++ b/scm/deployment_services/tests/api_internal_dns_servers_test.py
@@ -0,0 +1,218 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.deployment_services.models.internal_dns_servers import InternalDnsServers
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def internal_dns_servers_api(client):
+ """
+ Fixture to return the InternalDNSServers API instance.
+ """
+ return client.deployment_services.InternalDNSServersApi(client.deployment_services.api_client)
+
+
+@pytest.fixture
+def clean_internal_dns_server(internal_dns_servers_api):
+ """
+ Fixture to create a temporary Internal DNS Server for testing and automatically delete it after.
+ """
+ random_id = uuid.uuid4().hex[:6]
+ server_name = f"test-dns-srv-{random_id}"
+
+ payload = InternalDnsServers(
+ id="",
+ name=server_name,
+ domain_name=["example.com"],
+ primary="8.8.8.8"
+ )
+
+ logger.info(f"\n[SETUP] Creating InternalDnsServer: {server_name}")
+ created_obj = perform(
+ internal_dns_servers_api.create_internal_dns_servers_with_http_info,
+ response_type=InternalDnsServers,
+ internal_dns_servers=payload
+ )
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting InternalDnsServer ID: {created_obj.id}")
+ try:
+ internal_dns_servers_api.delete_internal_dns_servers_by_id(id=created_obj.id)
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_internal_dns_server(internal_dns_servers_api):
+ """
+ Test manual creation and deletion of an internal DNS server object.
+ Equivalent to Go: Test_deployment_services_InternalDNSServersAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ server_name = f"test-dns-srv-create-{random_suffix}"
+
+ payload = InternalDnsServers(
+ id="",
+ name=server_name,
+ domain_name=["example.com"],
+ primary="8.8.8.8"
+ )
+
+ # Create
+ created_obj = perform(
+ internal_dns_servers_api.create_internal_dns_servers_with_http_info,
+ response_type=InternalDnsServers,
+ internal_dns_servers=payload
+ )
+
+ # Verify
+ assert created_obj.name == server_name
+ assert created_obj.id is not None
+ assert created_obj.primary == "8.8.8.8"
+ assert "example.com" in created_obj.domain_name
+
+ # Cleanup
+ internal_dns_servers_api.delete_internal_dns_servers_by_id(id=created_obj.id)
+
+
+def test_get_internal_dns_server_by_id(internal_dns_servers_api, clean_internal_dns_server):
+ """
+ Test retrieving an internal DNS server by its ID.
+ Equivalent to Go: Test_deployment_services_InternalDNSServersAPIService_GetByID
+ """
+ fetched_obj = perform(
+ internal_dns_servers_api.get_internal_dns_servers_by_id_with_http_info,
+ response_type=InternalDnsServers,
+ id=clean_internal_dns_server.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_internal_dns_server.id
+ assert fetched_obj.name == clean_internal_dns_server.name
+
+
+def test_update_internal_dns_server(internal_dns_servers_api, clean_internal_dns_server):
+ """
+ Test updating an existing internal DNS server.
+ Equivalent to Go: Test_deployment_services_InternalDNSServersAPIService_Update
+ """
+ # Prepare Update Payload with modified fields
+ update_payload = InternalDnsServers(
+ id=clean_internal_dns_server.id,
+ name=clean_internal_dns_server.name,
+ domain_name=["example.com", "test.com"],
+ primary="1.1.1.1",
+ secondary="8.8.4.4"
+ )
+
+ # Perform Update
+ updated_obj = perform(
+ internal_dns_servers_api.update_internal_dns_servers_by_id_with_http_info,
+ response_type=InternalDnsServers,
+ id=clean_internal_dns_server.id,
+ internal_dns_servers=update_payload
+ )
+
+ # Verify
+ assert updated_obj.id == clean_internal_dns_server.id
+ assert updated_obj.primary == "1.1.1.1"
+ assert len(updated_obj.domain_name) == 2
+
+
+def test_list_internal_dns_servers(internal_dns_servers_api, clean_internal_dns_server):
+ """
+ Test listing internal DNS servers.
+ Equivalent to Go: Test_deployment_services_InternalDNSServersAPIService_List
+ """
+ response = internal_dns_servers_api.list_internal_dns_servers()
+
+ # Verify
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.id == clean_internal_dns_server.id:
+ found = True
+ assert item.name == clean_internal_dns_server.name
+ break
+ assert found is True, f"Created DNS server {clean_internal_dns_server.name} not found in list response"
+
+
+def test_fetch_internal_dns_servers(internal_dns_servers_api, clean_internal_dns_server):
+ """
+ Test fetching a single internal DNS server by name using the fetch convenience method.
+ Equivalent to Go: Test_deployment_services_InternalDNSServersAPIService_FetchInternalDNSServers
+ """
+ # Fetch by exact name
+ fetched_obj = internal_dns_servers_api.fetch_internal_dns_servers(
+ name=clean_internal_dns_server.name,
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found internal_dns_servers '{clean_internal_dns_server.name}'"
+ assert fetched_obj.id == clean_internal_dns_server.id
+ assert fetched_obj.name == clean_internal_dns_server.name
+ logger.info(f"\n[SUCCESS] fetch_internal_dns_servers found object: {fetched_obj.name}")
+
+ # Test fetching non-existent internal_dns_servers (should return None)
+ not_found = internal_dns_servers_api.fetch_internal_dns_servers(
+ name="non-existent-internal-dns-xyz-12345",
+ )
+ assert not_found is None, "Should return None for non-existent internal_dns_servers"
+ logger.info(f"\n[SUCCESS] fetch_internal_dns_servers correctly returned None for non-existent internal_dns_servers")
+
+
+def test_delete_internal_dns_server_by_id(internal_dns_servers_api):
+ """
+ Test deleting an internal DNS server.
+ Equivalent to Go: Test_deployment_services_InternalDNSServersAPIService_DeleteByID
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ server_name = f"test-dns-srv-delete-{random_suffix}"
+
+ payload = InternalDnsServers(
+ id="",
+ name=server_name,
+ domain_name=["example.com"],
+ primary="8.8.8.8"
+ )
+
+ # Create
+ created_obj = perform(
+ internal_dns_servers_api.create_internal_dns_servers_with_http_info,
+ response_type=InternalDnsServers,
+ internal_dns_servers=payload
+ )
+
+ # Delete
+ internal_dns_servers_api.delete_internal_dns_servers_by_id(id=created_obj.id)
+
+ # Verify deletion (expect ObjectNotPresentError)
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ internal_dns_servers_api.get_internal_dns_servers_by_id(id=created_obj.id)
+ pytest.fail("DNS server should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ logger.info(f"Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/deployment_services/tests/api_network_locations_test.py b/scm/deployment_services/tests/api_network_locations_test.py
new file mode 100644
index 00000000..2f8782da
--- /dev/null
+++ b/scm/deployment_services/tests/api_network_locations_test.py
@@ -0,0 +1,27 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def network_locations_api(client):
+ return client.deployment_services.NetworkLocationsApi(client.deployment_services.api_client)
+
+
+def test_list_locations(network_locations_api):
+ """Test listing Network Locations (read-only resource)."""
+ response = network_locations_api.list_locations()
+ assert response is not None
+ logger.info(f"Listed Network Locations successfully")
diff --git a/scm/deployment_services/tests/api_remote_networks_test.py b/scm/deployment_services/tests/api_remote_networks_test.py
new file mode 100644
index 00000000..cc1f7f29
--- /dev/null
+++ b/scm/deployment_services/tests/api_remote_networks_test.py
@@ -0,0 +1,403 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.network_services.models.ike_crypto_profiles import IkeCryptoProfiles
+from scm.network_services.models.ike_gateways import IkeGateways
+from scm.network_services.models.ike_gateways_authentication import IkeGatewaysAuthentication
+from scm.network_services.models.ike_gateways_authentication_pre_shared_key import IkeGatewaysAuthenticationPreSharedKey
+from scm.network_services.models.ike_gateways_peer_address import IkeGatewaysPeerAddress
+from scm.network_services.models.ike_gateways_peer_id import IkeGatewaysPeerId
+from scm.network_services.models.ike_gateways_local_id import IkeGatewaysLocalId
+from scm.network_services.models.ike_gateways_protocol import IkeGatewaysProtocol
+from scm.network_services.models.ike_gateways_protocol_ikev1 import IkeGatewaysProtocolIkev1
+from scm.network_services.models.ike_gateways_protocol_ikev1_dpd import IkeGatewaysProtocolIkev1Dpd
+from scm.network_services.models.ipsec_tunnels import IpsecTunnels
+from scm.network_services.models.ipsec_tunnels_auto_key import IpsecTunnelsAutoKey
+from scm.network_services.models.ipsec_tunnels_auto_key_ike_gateway_inner import IpsecTunnelsAutoKeyIkeGatewayInner
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "Remote Networks"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def network_services_client(client):
+ """Return network services API client for creating dependencies."""
+ return client.network_services
+
+
+@pytest.fixture(scope="module")
+def remote_networks_api(client):
+ """
+ Fixture to return the RemoteNetworks API instance.
+ """
+ return client.deployment_services.RemoteNetworksApi(client.deployment_services.api_client)
+
+
+def create_ike_crypto_profile(network_services_client, name, folder=TARGET_FOLDER):
+ """Helper to create an IKE Crypto Profile dependency."""
+ logger.info(f"Creating IKE Crypto Profile: {name}")
+
+ profile = IkeCryptoProfiles(
+ name=name,
+ folder=folder,
+ hash=["sha256"],
+ dh_group=["group14"],
+ encryption=["aes-256-cbc"]
+ )
+
+ created = perform(
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).create_ike_crypto_profiles_with_http_info,
+ response_type=IkeCryptoProfiles,
+ ike_crypto_profiles=profile
+ )
+
+ logger.info(f"Created IKE Crypto Profile '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_crypto_profile(network_services_client, profile_id, name):
+ """Helper to delete an IKE Crypto Profile."""
+ logger.info(f"Deleting IKE Crypto Profile: {name} (ID: {profile_id})")
+ try:
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).delete_ike_crypto_profiles_by_id(id=profile_id)
+ logger.info(f"Deleted IKE Crypto Profile: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Crypto Profile {name}: {e}")
+
+
+def create_ike_gateway(network_services_client, name, crypto_profile_name, folder=TARGET_FOLDER):
+ """Helper to create an IKE Gateway dependency."""
+ logger.info(f"Creating IKE Gateway: {name}")
+
+ gateway = IkeGateways(
+ name=name,
+ folder=folder,
+ authentication=IkeGatewaysAuthentication(
+ pre_shared_key=IkeGatewaysAuthenticationPreSharedKey(key="123456")
+ ),
+ peer_address=IkeGatewaysPeerAddress(ip="2.2.2.4"),
+ peer_id=IkeGatewaysPeerId(type="ipaddr", id="10.3.3.4"),
+ local_id=IkeGatewaysLocalId(type="ipaddr", id="10.3.4.4"),
+ protocol=IkeGatewaysProtocol(
+ ikev1=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ ),
+ ikev2=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ )
+ )
+ )
+
+ created = perform(
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).create_ike_gateways_with_http_info,
+ response_type=IkeGateways,
+ ike_gateways=gateway
+ )
+
+ logger.info(f"Created IKE Gateway '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_gateway(network_services_client, gateway_id, name):
+ """Helper to delete an IKE Gateway."""
+ logger.info(f"Deleting IKE Gateway: {name} (ID: {gateway_id})")
+ try:
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).delete_ike_gateways_by_id(id=gateway_id)
+ logger.info(f"Deleted IKE Gateway: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Gateway {name}: {e}")
+
+
+def create_ipsec_tunnel(network_services_client, name, gateway_name, folder=TARGET_FOLDER):
+ """Helper to create an IPsec Tunnel dependency."""
+ logger.info(f"Creating IPsec Tunnel: {name}")
+
+ tunnel = IpsecTunnels(
+ name=name,
+ folder=folder,
+ anti_replay=True,
+ copy_tos=False,
+ enable_gre_encapsulation=False,
+ auto_key=IpsecTunnelsAutoKey(
+ ike_gateway=[IpsecTunnelsAutoKeyIkeGatewayInner(name=gateway_name)],
+ ipsec_crypto_profile="PaloAlto-Networks-IPSec-Crypto"
+ )
+ )
+
+ created = perform(
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).create_i_psec_tunnels_with_http_info,
+ response_type=IpsecTunnels,
+ ipsec_tunnels=tunnel
+ )
+
+ logger.info(f"Created IPsec Tunnel '{name}' with ID: {created.id}")
+ return created.id, created.name
+
+
+def delete_ipsec_tunnel(network_services_client, tunnel_id, name):
+ """Helper to delete an IPsec Tunnel."""
+ logger.info(f"Deleting IPsec Tunnel: {name} (ID: {tunnel_id})")
+ try:
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).delete_i_psec_tunnels_by_id(id=tunnel_id)
+ logger.info(f"Deleted IPsec Tunnel: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IPsec Tunnel {name}: {e}")
+
+
+@pytest.fixture
+def ipsec_tunnel_with_deps(network_services_client):
+ """
+ Fixture to create a full IPsec Tunnel with all dependencies.
+ Creates: IKE Crypto Profile → IKE Gateway → IPsec Tunnel
+ Returns the tunnel name and cleanup function.
+ """
+ suffix = uuid.uuid4().hex[:6]
+
+ # Create IKE Crypto Profile
+ crypto_name = f"test-crypto-rn-{suffix}"
+ crypto_id = create_ike_crypto_profile(network_services_client, crypto_name)
+
+ # Create IKE Gateway
+ gateway_name = f"test-gw-rn-{suffix}"
+ gateway_id = create_ike_gateway(network_services_client, gateway_name, crypto_name)
+
+ # Create IPsec Tunnel
+ tunnel_name = f"test-tunnel-rn-{suffix}"
+ tunnel_id, tunnel_name = create_ipsec_tunnel(network_services_client, tunnel_name, gateway_name)
+
+ yield tunnel_name
+
+ # Cleanup in reverse order
+ delete_ipsec_tunnel(network_services_client, tunnel_id, tunnel_name)
+ delete_ike_gateway(network_services_client, gateway_id, gateway_name)
+ delete_ike_crypto_profile(network_services_client, crypto_id, crypto_name)
+
+
+@pytest.fixture
+def clean_remote_network(remote_networks_api, ipsec_tunnel_with_deps):
+ """
+ Fixture to create a temporary RemoteNetwork for testing and automatically delete it after.
+ """
+ random_id = uuid.uuid4().hex[:6]
+ network_name = f"test-rn-{random_id}"
+
+ payload = RemoteNetworks(
+ id="",
+ name=network_name,
+ folder=TARGET_FOLDER,
+ region="us-west-2",
+ license_type="FWAAS-AGGREGATE",
+ subnets=["192.168.1.0/24"],
+ ipsec_tunnel=ipsec_tunnel_with_deps,
+ spn_name="us-west-dakota"
+ )
+
+ logger.info(f"\n[SETUP] Creating RemoteNetwork: {network_name}")
+ created_obj = perform(
+ remote_networks_api.create_remote_networks_with_http_info,
+ response_type=RemoteNetworks,
+ remote_networks=payload
+ )
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting RemoteNetwork ID: {created_obj.id}")
+ try:
+ remote_networks_api.delete_remote_networks_by_id(id=created_obj.id)
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_remote_network(remote_networks_api, ipsec_tunnel_with_deps):
+ """
+ Test manual creation and deletion of a remote network object.
+ Equivalent to Go: Test_deployment_services_RemoteNetworksAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ network_name = f"test-rn-create-{random_suffix}"
+
+ payload = RemoteNetworks(
+ id="",
+ name=network_name,
+ folder=TARGET_FOLDER,
+ region="us-west-2",
+ license_type="FWAAS-AGGREGATE",
+ subnets=["192.168.1.0/24", "192.168.2.0/24"],
+ ipsec_tunnel=ipsec_tunnel_with_deps,
+ spn_name="us-west-dakota"
+ )
+
+ # Create
+ created_obj = perform(
+ remote_networks_api.create_remote_networks_with_http_info,
+ response_type=RemoteNetworks,
+ remote_networks=payload
+ )
+
+ # Verify
+ assert created_obj.name == network_name
+ assert created_obj.id is not None
+ assert created_obj.region == "us-west-2"
+ assert created_obj.license_type == "FWAAS-AGGREGATE"
+ assert set(created_obj.subnets) == set(["192.168.1.0/24", "192.168.2.0/24"])
+ assert created_obj.folder == TARGET_FOLDER
+
+ # Cleanup
+ remote_networks_api.delete_remote_networks_by_id(id=created_obj.id)
+
+
+def test_get_remote_network_by_id(remote_networks_api, clean_remote_network):
+ """
+ Test retrieving a remote network by its ID.
+ Equivalent to Go: Test_deployment_services_RemoteNetworksAPIService_GetByID
+ """
+ fetched_obj = perform(
+ remote_networks_api.get_remote_networks_by_id_with_http_info,
+ response_type=RemoteNetworks,
+ id=clean_remote_network.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_remote_network.id
+ assert fetched_obj.name == clean_remote_network.name
+
+
+def test_update_remote_network(remote_networks_api, clean_remote_network):
+ """
+ Test updating an existing remote network.
+ Equivalent to Go: Test_deployment_services_RemoteNetworksAPIService_Update
+ """
+ # Prepare Update Payload
+ update_payload = clean_remote_network
+ update_payload.subnets = ["10.0.0.0/8"]
+
+ # Perform Update
+ updated_obj = perform(
+ remote_networks_api.update_remote_networks_by_id_with_http_info,
+ response_type=RemoteNetworks,
+ id=clean_remote_network.id,
+ remote_networks=update_payload
+ )
+
+ # Verify
+ assert updated_obj.id == clean_remote_network.id
+ assert updated_obj.name == clean_remote_network.name
+ assert "10.0.0.0/8" in updated_obj.subnets
+
+
+def test_list_remote_networks(remote_networks_api, clean_remote_network):
+ """
+ Test listing remote networks.
+ Equivalent to Go: Test_deployment_services_RemoteNetworksAPIService_List
+ """
+ response = perform(
+ remote_networks_api.list_remote_networks_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ # Verify
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_remote_network.name:
+ found = True
+ break
+ assert found is True, f"Created network {clean_remote_network.name} not found in list response"
+
+
+
+
+def test_fetch_remote_networks(remote_networks_api, clean_remote_network):
+ """
+ Test fetching a single remote_networks by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = remote_networks_api.fetch_remote_networks(
+ name=clean_remote_network.name,
+ folder=clean_remote_network.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found remote_networks '{clean_remote_network.name}'"
+ assert fetched_obj.id == clean_remote_network.id
+ assert fetched_obj.name == clean_remote_network.name
+ assert fetched_obj.folder == clean_remote_network.folder
+ logger.info(f"\n[SUCCESS] fetch_remote_networks found object: {fetched_obj.name}")
+
+ # Test fetching non-existent remote_networks (should return None)
+ not_found = remote_networks_api.fetch_remote_networks(
+ name="non-existent-remote_networks-xyz-12345",
+ folder=clean_remote_network.folder
+ )
+ assert not_found is None, "Should return None for non-existent remote_networks"
+ logger.info(f"\n[SUCCESS] fetch_remote_networks correctly returned None for non-existent remote_networks")
+
+
+def test_delete_remote_network_by_id(remote_networks_api, ipsec_tunnel_with_deps):
+ """
+ Test deleting a remote network.
+ Equivalent to Go: Test_deployment_services_RemoteNetworksAPIService_DeleteByID
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ network_name = f"test-rn-delete-{random_suffix}"
+
+ payload = RemoteNetworks(
+ id="",
+ name=network_name,
+ folder=TARGET_FOLDER,
+ region="us-west-2",
+ license_type="FWAAS-AGGREGATE",
+ subnets=["192.168.1.0/24"],
+ ipsec_tunnel=ipsec_tunnel_with_deps,
+ spn_name="us-west-dakota"
+ )
+
+ # Create
+ created_obj = perform(
+ remote_networks_api.create_remote_networks_with_http_info,
+ response_type=RemoteNetworks,
+ remote_networks=payload
+ )
+
+ # Delete
+ remote_networks_api.delete_remote_networks_by_id(id=created_obj.id)
+
+ # Verify deletion (expect ObjectNotPresentError)
+ from scm.exceptions import ObjectNotPresentError
+ # Decorator already converts NotFoundException to ObjectNotPresentError
+
+ try:
+ remote_networks_api.get_remote_networks_by_id(id=created_obj.id)
+ pytest.fail("Network should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/deployment_services/tests/api_service_connection_groups_test.py b/scm/deployment_services/tests/api_service_connection_groups_test.py
new file mode 100644
index 00000000..31cbc378
--- /dev/null
+++ b/scm/deployment_services/tests/api_service_connection_groups_test.py
@@ -0,0 +1,406 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.deployment_services.models.service_connection_groups import ServiceConnectionGroups
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.network_services.models.ike_crypto_profiles import IkeCryptoProfiles
+from scm.network_services.models.ike_gateways import IkeGateways
+from scm.network_services.models.ike_gateways_authentication import IkeGatewaysAuthentication
+from scm.network_services.models.ike_gateways_authentication_pre_shared_key import IkeGatewaysAuthenticationPreSharedKey
+from scm.network_services.models.ike_gateways_peer_address import IkeGatewaysPeerAddress
+from scm.network_services.models.ike_gateways_peer_id import IkeGatewaysPeerId
+from scm.network_services.models.ike_gateways_local_id import IkeGatewaysLocalId
+from scm.network_services.models.ike_gateways_protocol import IkeGatewaysProtocol
+from scm.network_services.models.ike_gateways_protocol_ikev1 import IkeGatewaysProtocolIkev1
+from scm.network_services.models.ike_gateways_protocol_ikev1_dpd import IkeGatewaysProtocolIkev1Dpd
+from scm.network_services.models.ipsec_tunnels import IpsecTunnels
+from scm.network_services.models.ipsec_tunnels_auto_key import IpsecTunnelsAutoKey
+from scm.network_services.models.ipsec_tunnels_auto_key_ike_gateway_inner import IpsecTunnelsAutoKeyIkeGatewayInner
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "Service Connections"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def network_services_client(client):
+ """Return network services API client for creating dependencies."""
+ return client.network_services
+
+
+@pytest.fixture(scope="module")
+def deployment_services_client(client):
+ """Return deployment services API client."""
+ return client.deployment_services
+
+
+@pytest.fixture(scope="module")
+def service_connection_groups_api(client):
+ """
+ Fixture to return the ServiceConnectionGroups API instance.
+ """
+ return client.deployment_services.ServiceConnectionGroupsApi(client.deployment_services.api_client)
+
+
+def create_ike_crypto_profile(network_services_client, name, folder=TARGET_FOLDER):
+ """Helper to create an IKE Crypto Profile dependency."""
+ logger.info(f"Creating IKE Crypto Profile: {name}")
+
+ profile = IkeCryptoProfiles(
+ name=name,
+ folder=folder,
+ hash=["sha256"],
+ dh_group=["group14"],
+ encryption=["aes-256-cbc"]
+ )
+
+ created = perform(
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).create_ike_crypto_profiles_with_http_info,
+ response_type=IkeCryptoProfiles,
+ ike_crypto_profiles=profile
+ )
+
+ logger.info(f"Created IKE Crypto Profile '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_crypto_profile(network_services_client, profile_id, name):
+ """Helper to delete an IKE Crypto Profile."""
+ logger.info(f"Deleting IKE Crypto Profile: {name} (ID: {profile_id})")
+ try:
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).delete_ike_crypto_profiles_by_id(id=profile_id)
+ logger.info(f"Deleted IKE Crypto Profile: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Crypto Profile {name}: {e}")
+
+
+def create_ike_gateway(network_services_client, name, crypto_profile_name, folder=TARGET_FOLDER):
+ """Helper to create an IKE Gateway dependency."""
+ logger.info(f"Creating IKE Gateway: {name}")
+
+ gateway = IkeGateways(
+ name=name,
+ folder=folder,
+ authentication=IkeGatewaysAuthentication(
+ pre_shared_key=IkeGatewaysAuthenticationPreSharedKey(key="123456")
+ ),
+ peer_address=IkeGatewaysPeerAddress(ip="2.2.2.4"),
+ peer_id=IkeGatewaysPeerId(type="ipaddr", id="10.3.3.4"),
+ local_id=IkeGatewaysLocalId(type="ipaddr", id="10.3.4.4"),
+ protocol=IkeGatewaysProtocol(
+ ikev1=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ ),
+ ikev2=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ )
+ )
+ )
+
+ created = perform(
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).create_ike_gateways_with_http_info,
+ response_type=IkeGateways,
+ ike_gateways=gateway
+ )
+
+ logger.info(f"Created IKE Gateway '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_gateway(network_services_client, gateway_id, name):
+ """Helper to delete an IKE Gateway."""
+ logger.info(f"Deleting IKE Gateway: {name} (ID: {gateway_id})")
+ try:
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).delete_ike_gateways_by_id(id=gateway_id)
+ logger.info(f"Deleted IKE Gateway: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Gateway {name}: {e}")
+
+
+def create_ipsec_tunnel(network_services_client, name, gateway_name, folder=TARGET_FOLDER):
+ """Helper to create an IPsec Tunnel dependency."""
+ logger.info(f"Creating IPsec Tunnel: {name}")
+
+ tunnel = IpsecTunnels(
+ name=name,
+ folder=folder,
+ anti_replay=True,
+ copy_tos=False,
+ enable_gre_encapsulation=False,
+ auto_key=IpsecTunnelsAutoKey(
+ ike_gateway=[IpsecTunnelsAutoKeyIkeGatewayInner(name=gateway_name)],
+ ipsec_crypto_profile="PaloAlto-Networks-IPSec-Crypto"
+ )
+ )
+
+ created = perform(
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).create_i_psec_tunnels_with_http_info,
+ response_type=IpsecTunnels,
+ ipsec_tunnels=tunnel
+ )
+
+ logger.info(f"Created IPsec Tunnel '{name}' with ID: {created.id}")
+ return created.id, created.name
+
+
+def delete_ipsec_tunnel(network_services_client, tunnel_id, name):
+ """Helper to delete an IPsec Tunnel."""
+ logger.info(f"Deleting IPsec Tunnel: {name} (ID: {tunnel_id})")
+ try:
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).delete_i_psec_tunnels_by_id(id=tunnel_id)
+ logger.info(f"Deleted IPsec Tunnel: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IPsec Tunnel {name}: {e}")
+
+
+def create_service_connection(deployment_services_client, name, tunnel_name):
+ """Helper to create a Service Connection dependency."""
+ logger.info(f"Creating Service Connection: {name}")
+
+ sc = ServiceConnections(
+ id="",
+ name=name,
+ ipsec_tunnel=tunnel_name,
+ region="us-central1-a",
+ onboarding_type="classic",
+ subnets=["10.0.0.0/24"],
+ source_nat=True
+ )
+
+ created = perform(
+ deployment_services_client.ServiceConnectionsApi(deployment_services_client.api_client).create_service_connections_with_http_info,
+ response_type=ServiceConnections,
+ service_connections=sc
+ )
+
+ logger.info(f"Created Service Connection '{name}' with ID: {created.id}")
+ return created.id, created.name
+
+
+def delete_service_connection(deployment_services_client, sc_id, name):
+ """Helper to delete a Service Connection."""
+ logger.info(f"Deleting Service Connection: {name} (ID: {sc_id})")
+ try:
+ deployment_services_client.ServiceConnectionsApi(deployment_services_client.api_client).delete_service_connections_by_id(id=sc_id)
+ logger.info(f"Deleted Service Connection: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete Service Connection {name}: {e}")
+
+
+@pytest.fixture
+def service_connection_with_deps(network_services_client, deployment_services_client):
+ """
+ Fixture to create a full Service Connection with all dependencies.
+ Creates: IKE Crypto Profile → IKE Gateway → IPsec Tunnel → Service Connection
+ Returns the SC name and cleanup function.
+ """
+ suffix = uuid.uuid4().hex[:6]
+
+ # Create IKE Crypto Profile
+ crypto_name = f"test-crypto-scg-{suffix}"
+ crypto_id = create_ike_crypto_profile(network_services_client, crypto_name)
+
+ # Create IKE Gateway
+ gateway_name = f"test-gw-scg-{suffix}"
+ gateway_id = create_ike_gateway(network_services_client, gateway_name, crypto_name)
+
+ # Create IPsec Tunnel
+ tunnel_name = f"test-tunnel-scg-{suffix}"
+ tunnel_id, tunnel_name = create_ipsec_tunnel(network_services_client, tunnel_name, gateway_name)
+
+ # Create Service Connection
+ sc_name = f"test-sc-scg-{suffix}"
+ sc_id, sc_name = create_service_connection(deployment_services_client, sc_name, tunnel_name)
+
+ yield sc_name
+
+ # Cleanup in reverse order
+ delete_service_connection(deployment_services_client, sc_id, sc_name)
+ delete_ipsec_tunnel(network_services_client, tunnel_id, tunnel_name)
+ delete_ike_gateway(network_services_client, gateway_id, gateway_name)
+ delete_ike_crypto_profile(network_services_client, crypto_id, crypto_name)
+
+
+@pytest.fixture
+def clean_service_connection_group(service_connection_groups_api, service_connection_with_deps):
+ """
+ Fixture to create a temporary ServiceConnectionGroup for testing and automatically delete it after.
+ """
+ random_id = uuid.uuid4().hex[:6]
+ group_name = f"test-scg-{random_id}"
+
+ payload = ServiceConnectionGroups(
+ id="",
+ name=group_name,
+ target=[service_connection_with_deps],
+ disable_snat=True
+ )
+
+ logger.info(f"\n[SETUP] Creating ServiceConnectionGroup: {group_name}")
+ created_obj = perform(
+ service_connection_groups_api.create_service_connection_groups_with_http_info,
+ response_type=ServiceConnectionGroups,
+ service_connection_groups=payload
+ )
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting ServiceConnectionGroup ID: {created_obj.id}")
+ try:
+ service_connection_groups_api.delete_service_connection_groups_by_id(id=created_obj.id)
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_service_connection_group(service_connection_groups_api, service_connection_with_deps):
+ """
+ Test manual creation and deletion of a service connection group object.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionGroupsAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ group_name = f"test-scg-create-{random_suffix}"
+
+ payload = ServiceConnectionGroups(
+ id="",
+ name=group_name,
+ target=[service_connection_with_deps],
+ disable_snat=True
+ )
+
+ # Create
+ created_obj = perform(
+ service_connection_groups_api.create_service_connection_groups_with_http_info,
+ response_type=ServiceConnectionGroups,
+ service_connection_groups=payload
+ )
+
+ # Verify
+ assert created_obj.name == group_name
+ assert created_obj.id is not None
+ assert service_connection_with_deps in created_obj.target
+
+ # Cleanup
+ service_connection_groups_api.delete_service_connection_groups_by_id(id=created_obj.id)
+
+
+def test_get_service_connection_group_by_id(service_connection_groups_api, clean_service_connection_group):
+ """
+ Test retrieving a service connection group by its ID.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionGroupsAPIService_GetByID
+ """
+ fetched_obj = perform(
+ service_connection_groups_api.get_service_connection_groups_by_id_with_http_info,
+ response_type=ServiceConnectionGroups,
+ id=clean_service_connection_group.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_service_connection_group.id
+ assert fetched_obj.name == clean_service_connection_group.name
+
+
+def test_update_service_connection_group(service_connection_groups_api, clean_service_connection_group):
+ """
+ Test updating an existing service connection group.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionGroupsAPIService_Update
+ """
+ # Prepare Update Payload
+ update_payload = clean_service_connection_group
+ update_payload.disable_snat = False
+
+ # Perform Update
+ updated_obj = perform(
+ service_connection_groups_api.update_service_connection_groups_by_id_with_http_info,
+ response_type=ServiceConnectionGroups,
+ id=clean_service_connection_group.id,
+ service_connection_groups=update_payload
+ )
+
+ # Verify
+ assert updated_obj.id == clean_service_connection_group.id
+ assert updated_obj.name == clean_service_connection_group.name
+ assert updated_obj.disable_snat is False
+
+
+def test_list_service_connection_groups(service_connection_groups_api, clean_service_connection_group):
+ """
+ Test listing service connection groups.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionGroupsAPIService_List
+ """
+ response = perform(
+ service_connection_groups_api.list_service_connection_groups_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ # Verify
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_service_connection_group.name:
+ found = True
+ break
+ assert found is True, f"Created group {clean_service_connection_group.name} not found in list response"
+
+
+
+def test_delete_service_connection_group_by_id(service_connection_groups_api, service_connection_with_deps):
+ """
+ Test deleting a service connection group.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionGroupsAPIService_DeleteByID
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ group_name = f"test-scg-delete-{random_suffix}"
+
+ payload = ServiceConnectionGroups(
+ id="",
+ name=group_name,
+ target=[service_connection_with_deps],
+ disable_snat=True
+ )
+
+ # Create
+ created_obj = perform(
+ service_connection_groups_api.create_service_connection_groups_with_http_info,
+ response_type=ServiceConnectionGroups,
+ service_connection_groups=payload
+ )
+
+ # Delete
+ service_connection_groups_api.delete_service_connection_groups_by_id(id=created_obj.id)
+
+ # Verify deletion (expect ObjectNotPresentError)
+ from scm.exceptions import ObjectNotPresentError
+ # Decorator already converts NotFoundException to ObjectNotPresentError
+
+ try:
+ service_connection_groups_api.get_service_connection_groups_by_id(id=created_obj.id)
+ pytest.fail("Group should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/deployment_services/tests/api_service_connections_test.py b/scm/deployment_services/tests/api_service_connections_test.py
new file mode 100644
index 00000000..f129375f
--- /dev/null
+++ b/scm/deployment_services/tests/api_service_connections_test.py
@@ -0,0 +1,370 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.deployment_services.models.service_connections import ServiceConnections
+from scm.network_services.models.ike_crypto_profiles import IkeCryptoProfiles
+from scm.network_services.models.ike_gateways import IkeGateways
+from scm.network_services.models.ike_gateways_authentication import IkeGatewaysAuthentication
+from scm.network_services.models.ike_gateways_authentication_pre_shared_key import IkeGatewaysAuthenticationPreSharedKey
+from scm.network_services.models.ike_gateways_peer_address import IkeGatewaysPeerAddress
+from scm.network_services.models.ike_gateways_peer_id import IkeGatewaysPeerId
+from scm.network_services.models.ike_gateways_local_id import IkeGatewaysLocalId
+from scm.network_services.models.ike_gateways_protocol import IkeGatewaysProtocol
+from scm.network_services.models.ike_gateways_protocol_ikev1 import IkeGatewaysProtocolIkev1
+from scm.network_services.models.ike_gateways_protocol_ikev1_dpd import IkeGatewaysProtocolIkev1Dpd
+from scm.network_services.models.ipsec_tunnels import IpsecTunnels
+from scm.network_services.models.ipsec_tunnels_auto_key import IpsecTunnelsAutoKey
+from scm.network_services.models.ipsec_tunnels_auto_key_ike_gateway_inner import IpsecTunnelsAutoKeyIkeGatewayInner
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "Service Connections"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def network_services_client(client):
+ """Return network services API client for creating dependencies."""
+ return client.network_services
+
+
+@pytest.fixture(scope="module")
+def service_connections_api(client):
+ """
+ Fixture to return the ServiceConnections API instance.
+ """
+ return client.deployment_services.ServiceConnectionsApi(client.deployment_services.api_client)
+
+
+def create_ike_crypto_profile(network_services_client, name, folder=TARGET_FOLDER):
+ """Helper to create an IKE Crypto Profile dependency."""
+ logger.info(f"Creating IKE Crypto Profile: {name}")
+
+ profile = IkeCryptoProfiles(
+ name=name,
+ folder=folder,
+ hash=["sha256"],
+ dh_group=["group14"],
+ encryption=["aes-256-cbc"]
+ )
+
+ created = perform(
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).create_ike_crypto_profiles_with_http_info,
+ response_type=IkeCryptoProfiles,
+ ike_crypto_profiles=profile
+ )
+
+ logger.info(f"Created IKE Crypto Profile '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_crypto_profile(network_services_client, profile_id, name):
+ """Helper to delete an IKE Crypto Profile."""
+ logger.info(f"Deleting IKE Crypto Profile: {name} (ID: {profile_id})")
+ try:
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).delete_ike_crypto_profiles_by_id(id=profile_id)
+ logger.info(f"Deleted IKE Crypto Profile: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Crypto Profile {name}: {e}")
+
+
+def create_ike_gateway(network_services_client, name, crypto_profile_name, folder=TARGET_FOLDER):
+ """Helper to create an IKE Gateway dependency."""
+ logger.info(f"Creating IKE Gateway: {name}")
+
+ gateway = IkeGateways(
+ name=name,
+ folder=folder,
+ authentication=IkeGatewaysAuthentication(
+ pre_shared_key=IkeGatewaysAuthenticationPreSharedKey(key="123456")
+ ),
+ peer_address=IkeGatewaysPeerAddress(ip="2.2.2.4"),
+ peer_id=IkeGatewaysPeerId(type="ipaddr", id="10.3.3.4"),
+ local_id=IkeGatewaysLocalId(type="ipaddr", id="10.3.4.4"),
+ protocol=IkeGatewaysProtocol(
+ ikev1=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ ),
+ ikev2=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ )
+ )
+ )
+
+ created = perform(
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).create_ike_gateways_with_http_info,
+ response_type=IkeGateways,
+ ike_gateways=gateway
+ )
+
+ logger.info(f"Created IKE Gateway '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_gateway(network_services_client, gateway_id, name):
+ """Helper to delete an IKE Gateway."""
+ logger.info(f"Deleting IKE Gateway: {name} (ID: {gateway_id})")
+ try:
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).delete_ike_gateways_by_id(id=gateway_id)
+ logger.info(f"Deleted IKE Gateway: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Gateway {name}: {e}")
+
+
+def create_ipsec_tunnel(network_services_client, name, gateway_name, folder=TARGET_FOLDER):
+ """Helper to create an IPsec Tunnel dependency."""
+ logger.info(f"Creating IPsec Tunnel: {name}")
+
+ tunnel = IpsecTunnels(
+ name=name,
+ folder=folder,
+ anti_replay=True,
+ copy_tos=False,
+ enable_gre_encapsulation=False,
+ auto_key=IpsecTunnelsAutoKey(
+ ike_gateway=[IpsecTunnelsAutoKeyIkeGatewayInner(name=gateway_name)],
+ ipsec_crypto_profile="PaloAlto-Networks-IPSec-Crypto"
+ )
+ )
+
+ created = perform(
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).create_i_psec_tunnels_with_http_info,
+ response_type=IpsecTunnels,
+ ipsec_tunnels=tunnel
+ )
+
+ logger.info(f"Created IPsec Tunnel '{name}' with ID: {created.id}")
+ return created.id, created.name
+
+
+def delete_ipsec_tunnel(network_services_client, tunnel_id, name):
+ """Helper to delete an IPsec Tunnel."""
+ logger.info(f"Deleting IPsec Tunnel: {name} (ID: {tunnel_id})")
+ try:
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).delete_i_psec_tunnels_by_id(id=tunnel_id)
+ logger.info(f"Deleted IPsec Tunnel: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IPsec Tunnel {name}: {e}")
+
+
+@pytest.fixture
+def ipsec_tunnel_with_deps(network_services_client):
+ """
+ Fixture to create a full IPsec Tunnel with all dependencies.
+ Creates: IKE Crypto Profile → IKE Gateway → IPsec Tunnel
+ Returns the tunnel name and cleanup function.
+ """
+ suffix = uuid.uuid4().hex[:6]
+
+ # Create IKE Crypto Profile
+ crypto_name = f"test-crypto-sc-{suffix}"
+ crypto_id = create_ike_crypto_profile(network_services_client, crypto_name)
+
+ # Create IKE Gateway
+ gateway_name = f"test-gw-sc-{suffix}"
+ gateway_id = create_ike_gateway(network_services_client, gateway_name, crypto_name)
+
+ # Create IPsec Tunnel
+ tunnel_name = f"test-tunnel-sc-{suffix}"
+ tunnel_id, tunnel_name = create_ipsec_tunnel(network_services_client, tunnel_name, gateway_name)
+
+ yield tunnel_name
+
+ # Cleanup in reverse order
+ delete_ipsec_tunnel(network_services_client, tunnel_id, tunnel_name)
+ delete_ike_gateway(network_services_client, gateway_id, gateway_name)
+ delete_ike_crypto_profile(network_services_client, crypto_id, crypto_name)
+
+
+@pytest.fixture
+def clean_service_connection(service_connections_api, ipsec_tunnel_with_deps):
+ """
+ Fixture to create a temporary ServiceConnection for testing and automatically delete it after.
+ """
+ random_id = uuid.uuid4().hex[:6]
+ sc_name = f"test-sc-{random_id}"
+
+ payload = ServiceConnections(
+ id="",
+ name=sc_name,
+ ipsec_tunnel=ipsec_tunnel_with_deps,
+ region="us-central1-a",
+ onboarding_type="classic",
+ subnets=["10.0.0.0/24", "10.0.1.0/24"],
+ source_nat=True
+ )
+
+ logger.info(f"\n[SETUP] Creating ServiceConnection: {sc_name}")
+ created_obj = perform(
+ service_connections_api.create_service_connections_with_http_info,
+ response_type=ServiceConnections,
+ service_connections=payload
+ )
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting ServiceConnection ID: {created_obj.id}")
+ try:
+ service_connections_api.delete_service_connections_by_id(id=created_obj.id)
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_service_connection(service_connections_api, ipsec_tunnel_with_deps):
+ """
+ Test manual creation and deletion of a service connection object.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionsAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ sc_name = f"test-sc-create-{random_suffix}"
+
+ payload = ServiceConnections(
+ id="",
+ name=sc_name,
+ ipsec_tunnel=ipsec_tunnel_with_deps,
+ region="us-central1-a",
+ onboarding_type="classic",
+ subnets=["10.0.0.0/24", "10.0.1.0/24"],
+ source_nat=True
+ )
+
+ # Create
+ created_obj = perform(
+ service_connections_api.create_service_connections_with_http_info,
+ response_type=ServiceConnections,
+ service_connections=payload
+ )
+
+ # Verify
+ assert created_obj.name == sc_name
+ assert created_obj.id is not None
+ assert created_obj.region == "us-central1-a"
+ assert created_obj.ipsec_tunnel == ipsec_tunnel_with_deps
+
+ # Cleanup
+ service_connections_api.delete_service_connections_by_id(id=created_obj.id)
+
+
+def test_get_service_connection_by_id(service_connections_api, clean_service_connection):
+ """
+ Test retrieving a service connection by its ID.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionsAPIService_GetByID
+ """
+ fetched_obj = perform(
+ service_connections_api.get_service_connections_by_id_with_http_info,
+ response_type=ServiceConnections,
+ id=clean_service_connection.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_service_connection.id
+ assert fetched_obj.name == clean_service_connection.name
+
+
+def test_update_service_connection(service_connections_api, clean_service_connection):
+ """
+ Test updating an existing service connection.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionsAPIService_Update
+ """
+ # Prepare Update Payload
+ update_payload = clean_service_connection
+ update_payload.subnets = ["192.168.0.0/16"]
+
+ # Perform Update
+ updated_obj = perform(
+ service_connections_api.update_service_connections_by_id_with_http_info,
+ response_type=ServiceConnections,
+ id=clean_service_connection.id,
+ service_connections=update_payload
+ )
+
+ # Verify
+ assert updated_obj.id == clean_service_connection.id
+ assert updated_obj.name == clean_service_connection.name
+ assert "192.168.0.0/16" in updated_obj.subnets
+
+
+def test_list_service_connections(service_connections_api, clean_service_connection):
+ """
+ Test listing service connections.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionsAPIService_List
+ """
+ response = perform(
+ service_connections_api.list_service_connections_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ # Verify
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_service_connection.name:
+ found = True
+ break
+ assert found is True, f"Created connection {clean_service_connection.name} not found in list response"
+
+
+
+def test_delete_service_connection_by_id(service_connections_api, ipsec_tunnel_with_deps):
+ """
+ Test deleting a service connection.
+ Equivalent to Go: Test_deployment_services_ServiceConnectionsAPIService_DeleteByID
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ sc_name = f"test-sc-delete-{random_suffix}"
+
+ payload = ServiceConnections(
+ id="",
+ name=sc_name,
+ ipsec_tunnel=ipsec_tunnel_with_deps,
+ region="us-central1-a",
+ onboarding_type="classic",
+ subnets=["10.0.0.0/24"],
+ source_nat=True
+ )
+
+ # Create
+ created_obj = perform(
+ service_connections_api.create_service_connections_with_http_info,
+ response_type=ServiceConnections,
+ service_connections=payload
+ )
+
+ # Delete
+ service_connections_api.delete_service_connections_by_id(id=created_obj.id)
+
+ # Verify deletion (expect ObjectNotPresentError)
+ from scm.exceptions import ObjectNotPresentError
+ # Decorator already converts NotFoundException to ObjectNotPresentError
+
+ try:
+ service_connections_api.get_service_connections_by_id(id=created_obj.id)
+ pytest.fail("Connection should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/deployment_services/tests/api_sites_test.py b/scm/deployment_services/tests/api_sites_test.py
new file mode 100644
index 00000000..47a5e134
--- /dev/null
+++ b/scm/deployment_services/tests/api_sites_test.py
@@ -0,0 +1,453 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.deployment_services.models.sites import Sites
+from scm.deployment_services.models.sites_members_inner import SitesMembersInner
+from scm.deployment_services.models.remote_networks import RemoteNetworks
+from scm.network_services.models.ike_crypto_profiles import IkeCryptoProfiles
+from scm.network_services.models.ike_gateways import IkeGateways
+from scm.network_services.models.ike_gateways_authentication import IkeGatewaysAuthentication
+from scm.network_services.models.ike_gateways_authentication_pre_shared_key import IkeGatewaysAuthenticationPreSharedKey
+from scm.network_services.models.ike_gateways_peer_address import IkeGatewaysPeerAddress
+from scm.network_services.models.ike_gateways_peer_id import IkeGatewaysPeerId
+from scm.network_services.models.ike_gateways_local_id import IkeGatewaysLocalId
+from scm.network_services.models.ike_gateways_protocol import IkeGatewaysProtocol
+from scm.network_services.models.ike_gateways_protocol_ikev1 import IkeGatewaysProtocolIkev1
+from scm.network_services.models.ike_gateways_protocol_ikev1_dpd import IkeGatewaysProtocolIkev1Dpd
+from scm.network_services.models.ipsec_tunnels import IpsecTunnels
+from scm.network_services.models.ipsec_tunnels_auto_key import IpsecTunnelsAutoKey
+from scm.network_services.models.ipsec_tunnels_auto_key_ike_gateway_inner import IpsecTunnelsAutoKeyIkeGatewayInner
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+RN_FOLDER = "Remote Networks"
+SITES_LIST_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def network_services_client(client):
+ """Return network services API client for creating dependencies."""
+ return client.network_services
+
+
+@pytest.fixture(scope="module")
+def deployment_services_client(client):
+ """Return deployment services API client."""
+ return client.deployment_services
+
+
+@pytest.fixture(scope="module")
+def sites_api(client):
+ """
+ Fixture to return the Sites API instance.
+ """
+ return client.deployment_services.SitesApi(client.deployment_services.api_client)
+
+
+def create_ike_crypto_profile(network_services_client, name, folder=RN_FOLDER):
+ """Helper to create an IKE Crypto Profile dependency."""
+ logger.info(f"Creating IKE Crypto Profile: {name}")
+
+ profile = IkeCryptoProfiles(
+ name=name,
+ folder=folder,
+ hash=["sha256"],
+ dh_group=["group14"],
+ encryption=["aes-256-cbc"]
+ )
+
+ created = perform(
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).create_ike_crypto_profiles_with_http_info,
+ response_type=IkeCryptoProfiles,
+ ike_crypto_profiles=profile
+ )
+
+ logger.info(f"Created IKE Crypto Profile '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_crypto_profile(network_services_client, profile_id, name):
+ """Helper to delete an IKE Crypto Profile."""
+ logger.info(f"Deleting IKE Crypto Profile: {name} (ID: {profile_id})")
+ try:
+ network_services_client.IKECryptoProfilesApi(network_services_client.api_client).delete_ike_crypto_profiles_by_id(id=profile_id)
+ logger.info(f"Deleted IKE Crypto Profile: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Crypto Profile {name}: {e}")
+
+
+def create_ike_gateway(network_services_client, name, crypto_profile_name, folder=RN_FOLDER):
+ """Helper to create an IKE Gateway dependency."""
+ logger.info(f"Creating IKE Gateway: {name}")
+
+ gateway = IkeGateways(
+ name=name,
+ folder=folder,
+ authentication=IkeGatewaysAuthentication(
+ pre_shared_key=IkeGatewaysAuthenticationPreSharedKey(key="123456")
+ ),
+ peer_address=IkeGatewaysPeerAddress(ip="2.2.2.4"),
+ peer_id=IkeGatewaysPeerId(type="ipaddr", id="10.3.3.4"),
+ local_id=IkeGatewaysLocalId(type="ipaddr", id="10.3.4.4"),
+ protocol=IkeGatewaysProtocol(
+ ikev1=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ ),
+ ikev2=IkeGatewaysProtocolIkev1(
+ ike_crypto_profile=crypto_profile_name,
+ dpd=IkeGatewaysProtocolIkev1Dpd(enable=True)
+ )
+ )
+ )
+
+ created = perform(
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).create_ike_gateways_with_http_info,
+ response_type=IkeGateways,
+ ike_gateways=gateway
+ )
+
+ logger.info(f"Created IKE Gateway '{name}' with ID: {created.id}")
+ return created.id
+
+
+def delete_ike_gateway(network_services_client, gateway_id, name):
+ """Helper to delete an IKE Gateway."""
+ logger.info(f"Deleting IKE Gateway: {name} (ID: {gateway_id})")
+ try:
+ network_services_client.IKEGatewaysApi(network_services_client.api_client).delete_ike_gateways_by_id(id=gateway_id)
+ logger.info(f"Deleted IKE Gateway: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IKE Gateway {name}: {e}")
+
+
+def create_ipsec_tunnel(network_services_client, name, gateway_name, folder=RN_FOLDER):
+ """Helper to create an IPsec Tunnel dependency."""
+ logger.info(f"Creating IPsec Tunnel: {name}")
+
+ tunnel = IpsecTunnels(
+ name=name,
+ folder=folder,
+ anti_replay=True,
+ copy_tos=False,
+ enable_gre_encapsulation=False,
+ auto_key=IpsecTunnelsAutoKey(
+ ike_gateway=[IpsecTunnelsAutoKeyIkeGatewayInner(name=gateway_name)],
+ ipsec_crypto_profile="PaloAlto-Networks-IPSec-Crypto"
+ )
+ )
+
+ created = perform(
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).create_i_psec_tunnels_with_http_info,
+ response_type=IpsecTunnels,
+ ipsec_tunnels=tunnel
+ )
+
+ logger.info(f"Created IPsec Tunnel '{name}' with ID: {created.id}")
+ return created.id, created.name
+
+
+def delete_ipsec_tunnel(network_services_client, tunnel_id, name):
+ """Helper to delete an IPsec Tunnel."""
+ logger.info(f"Deleting IPsec Tunnel: {name} (ID: {tunnel_id})")
+ try:
+ network_services_client.IPsecTunnelsApi(network_services_client.api_client).delete_i_psec_tunnels_by_id(id=tunnel_id)
+ logger.info(f"Deleted IPsec Tunnel: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete IPsec Tunnel {name}: {e}")
+
+
+def create_remote_network(deployment_services_client, name, tunnel_name):
+ """Helper to create a Remote Network dependency for site members."""
+ logger.info(f"Creating Remote Network: {name}")
+
+ rn = RemoteNetworks(
+ id="",
+ name=name,
+ folder=RN_FOLDER,
+ spn_name="us-west-dakota",
+ license_type="FWAAS-AGGREGATE",
+ region="us-west-2",
+ ipsec_tunnel=tunnel_name
+ )
+
+ created = perform(
+ deployment_services_client.RemoteNetworksApi(deployment_services_client.api_client).create_remote_networks_with_http_info,
+ response_type=RemoteNetworks,
+ remote_networks=rn
+ )
+
+ logger.info(f"Created Remote Network '{name}' with ID: {created.id}")
+ return created.id, created.name
+
+
+def delete_remote_network(deployment_services_client, rn_id, name):
+ """Helper to delete a Remote Network."""
+ logger.info(f"Deleting Remote Network: {name} (ID: {rn_id})")
+ try:
+ deployment_services_client.RemoteNetworksApi(deployment_services_client.api_client).delete_remote_networks_by_id(id=rn_id)
+ logger.info(f"Deleted Remote Network: {name}")
+ except Exception as e:
+ logger.error(f"Failed to delete Remote Network {name}: {e}")
+
+
+@pytest.fixture
+def remote_network_with_deps(network_services_client, deployment_services_client):
+ """
+ Fixture to create a Remote Network with all its IPsec tunnel dependencies.
+ Creates: IKE Crypto Profile -> IKE Gateway -> IPsec Tunnel -> Remote Network
+ Returns the remote network name.
+ """
+ suffix = uuid.uuid4().hex[:6]
+
+ # Create IKE Crypto Profile
+ crypto_name = f"test-crypto-s-{suffix}"
+ crypto_id = create_ike_crypto_profile(network_services_client, crypto_name)
+
+ # Create IKE Gateway
+ gateway_name = f"test-gw-s-{suffix}"
+ gateway_id = create_ike_gateway(network_services_client, gateway_name, crypto_name)
+
+ # Create IPsec Tunnel
+ tunnel_name = f"test-tunnel-s-{suffix}"
+ tunnel_id, tunnel_name = create_ipsec_tunnel(network_services_client, tunnel_name, gateway_name)
+
+ # Create Remote Network
+ rn_name = f"test-rn-s-{suffix}"
+ rn_id, rn_name = create_remote_network(deployment_services_client, rn_name, tunnel_name)
+
+ yield rn_name
+
+ # Cleanup in reverse order
+ delete_remote_network(deployment_services_client, rn_id, rn_name)
+ delete_ipsec_tunnel(network_services_client, tunnel_id, tunnel_name)
+ delete_ike_gateway(network_services_client, gateway_id, gateway_name)
+ delete_ike_crypto_profile(network_services_client, crypto_id, crypto_name)
+
+
+@pytest.fixture
+def clean_site(sites_api, remote_network_with_deps):
+ """
+ Fixture to create a temporary Site for testing and automatically delete it after.
+ """
+ random_id = uuid.uuid4().hex[:6]
+ site_name = f"test-site-{random_id}"
+
+ payload = Sites(
+ name=site_name,
+ city="San Jose",
+ country="US",
+ state="California",
+ members=[
+ SitesMembersInner(
+ name=remote_network_with_deps,
+ mode="active",
+ remote_network=remote_network_with_deps
+ )
+ ]
+ )
+
+ logger.info(f"\n[SETUP] Creating Site: {site_name}")
+ created_obj = perform(
+ sites_api.create_sites_with_http_info,
+ response_type=Sites,
+ sites=payload
+ )
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting Site ID: {created_obj.id}")
+ try:
+ sites_api.delete_sites_by_id(id=created_obj.id)
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_site(sites_api, remote_network_with_deps):
+ """
+ Test manual creation and deletion of a site object.
+ Equivalent to Go: Test_deployment_services_SitesAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ site_name = f"test-site-create-{random_suffix}"
+
+ payload = Sites(
+ name=site_name,
+ city="San Jose",
+ country="US",
+ state="California",
+ members=[
+ SitesMembersInner(
+ name=remote_network_with_deps,
+ mode="active",
+ remote_network=remote_network_with_deps
+ )
+ ]
+ )
+
+ # Create
+ created_obj = perform(
+ sites_api.create_sites_with_http_info,
+ response_type=Sites,
+ sites=payload
+ )
+
+ # Verify
+ assert created_obj.name == site_name
+ assert created_obj.id is not None
+
+ # Cleanup
+ sites_api.delete_sites_by_id(id=created_obj.id)
+
+
+def test_get_site_by_id(sites_api, clean_site):
+ """
+ Test retrieving a site by its ID.
+ Equivalent to Go: Test_deployment_services_SitesAPIService_GetByID
+ """
+ fetched_obj = perform(
+ sites_api.get_sites_by_id_with_http_info,
+ response_type=Sites,
+ id=clean_site.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_site.id
+ assert fetched_obj.name == clean_site.name
+
+
+def test_update_site(sites_api, clean_site):
+ """
+ Test updating an existing site.
+ Equivalent to Go: Test_deployment_services_SitesAPIService_Update
+ """
+ # Prepare Update Payload with modified address
+ update_payload = Sites(
+ name=clean_site.name,
+ id=clean_site.id,
+ address_line_1="123 Updated Street",
+ city="San Jose",
+ country="US",
+ state="California",
+ members=clean_site.members
+ )
+
+ # Perform Update
+ updated_obj = perform(
+ sites_api.update_sites_by_id_with_http_info,
+ response_type=Sites,
+ id=clean_site.id,
+ sites=update_payload
+ )
+
+ # Verify
+ assert updated_obj.id == clean_site.id
+ assert updated_obj.name == clean_site.name
+ assert updated_obj.address_line_1 == "123 Updated Street"
+
+
+def test_list_sites(sites_api, clean_site):
+ """
+ Test listing sites.
+ Equivalent to Go: Test_deployment_services_SitesAPIService_List
+ """
+ response = sites_api.list_sites(
+ folder=SITES_LIST_FOLDER,
+ limit=200,
+ offset=0
+ )
+
+ # Verify
+ assert response is not None
+ assert response.total > 0
+ logger.info(f"Successfully listed sites, total: {response.total}")
+
+
+def test_fetch_sites(sites_api, clean_site):
+ """
+ Test fetching a single site by name using the fetch convenience method.
+ Equivalent to Go: Test_deployment_services_SitesAPIService_FetchSites
+ """
+ # Fetch by exact name
+ fetched_obj = sites_api.fetch_sites(
+ name=clean_site.name,
+ folder=SITES_LIST_FOLDER
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found site '{clean_site.name}'"
+ assert fetched_obj.id == clean_site.id
+ assert fetched_obj.name == clean_site.name
+ logger.info(f"\n[SUCCESS] fetch_sites found object: {fetched_obj.name}")
+
+ # Test fetching non-existent site (should return None)
+ not_found = sites_api.fetch_sites(
+ name="non-existent-site-xyz-12345",
+ folder=SITES_LIST_FOLDER
+ )
+ assert not_found is None, "Should return None for non-existent site"
+ logger.info(f"\n[SUCCESS] fetch_sites correctly returned None for non-existent site")
+
+
+def test_delete_site_by_id(sites_api, remote_network_with_deps):
+ """
+ Test deleting a site.
+ Equivalent to Go: Test_deployment_services_SitesAPIService_DeleteByID
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ site_name = f"test-site-delete-{random_suffix}"
+
+ payload = Sites(
+ name=site_name,
+ city="San Jose",
+ country="US",
+ state="California",
+ members=[
+ SitesMembersInner(
+ name=remote_network_with_deps,
+ mode="active",
+ remote_network=remote_network_with_deps
+ )
+ ]
+ )
+
+ # Create
+ created_obj = perform(
+ sites_api.create_sites_with_http_info,
+ response_type=Sites,
+ sites=payload
+ )
+
+ # Delete
+ sites_api.delete_sites_by_id(id=created_obj.id)
+
+ # Verify deletion (expect ObjectNotPresentError)
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ sites_api.get_sites_by_id(id=created_obj.id)
+ pytest.fail("Site should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ logger.info(f"Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/deployment_services/tests/api_traffic_steering_rules_test.py b/scm/deployment_services/tests/api_traffic_steering_rules_test.py
new file mode 100644
index 00000000..3409d8fd
--- /dev/null
+++ b/scm/deployment_services/tests/api_traffic_steering_rules_test.py
@@ -0,0 +1,240 @@
+
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.deployment_services.models.traffic_steering_rules import TrafficSteeringRules
+from scm.deployment_services.models.traffic_steering_rules_action import TrafficSteeringRulesAction
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "Service Connections"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def traffic_steering_rules_api(client):
+ """
+ Fixture to return the TrafficSteeringRules API instance.
+ """
+ return client.deployment_services.TrafficSteeringRulesApi(client.deployment_services.api_client)
+
+
+@pytest.fixture
+def clean_traffic_steering_rule(traffic_steering_rules_api):
+ """
+ Fixture to create a temporary Traffic Steering Rule for testing and automatically delete it after.
+ """
+ random_id = uuid.uuid4().hex[:6]
+ rule_name = f"test-tsr-{random_id}"
+
+ payload = TrafficSteeringRules(
+ id="",
+ name=rule_name,
+ folder=TARGET_FOLDER,
+ service=["any"],
+ source=["any"],
+ action=TrafficSteeringRulesAction()
+ )
+
+ logger.info(f"\n[SETUP] Creating TrafficSteeringRule: {rule_name}")
+ created_obj = perform(
+ traffic_steering_rules_api.create_traffic_steering_rules_with_http_info,
+ response_type=TrafficSteeringRules,
+ folder=TARGET_FOLDER,
+ traffic_steering_rules=payload
+ )
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting TrafficSteeringRule ID: {created_obj.id}")
+ try:
+ traffic_steering_rules_api.delete_traffic_steering_rules_by_id(id=created_obj.id)
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_traffic_steering_rule(traffic_steering_rules_api):
+ """
+ Test manual creation and deletion of a traffic steering rule object.
+ Equivalent to Go: Test_deployment_services_TrafficSteeringRulesAPIService_Create
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ rule_name = f"test-tsr-create-{random_suffix}"
+
+ payload = TrafficSteeringRules(
+ id="",
+ name=rule_name,
+ folder=TARGET_FOLDER,
+ service=["any"],
+ source=["any"],
+ action=TrafficSteeringRulesAction()
+ )
+
+ # Create
+ created_obj = perform(
+ traffic_steering_rules_api.create_traffic_steering_rules_with_http_info,
+ response_type=TrafficSteeringRules,
+ folder=TARGET_FOLDER,
+ traffic_steering_rules=payload
+ )
+
+ # Verify
+ assert created_obj.name == rule_name
+ assert created_obj.id is not None
+ assert created_obj.folder == TARGET_FOLDER
+
+ # Cleanup
+ traffic_steering_rules_api.delete_traffic_steering_rules_by_id(id=created_obj.id)
+
+
+def test_get_traffic_steering_rule_by_id(traffic_steering_rules_api, clean_traffic_steering_rule):
+ """
+ Test retrieving a traffic steering rule by its ID.
+ Equivalent to Go: Test_deployment_services_TrafficSteeringRulesAPIService_GetByID
+ """
+ fetched_obj = perform(
+ traffic_steering_rules_api.get_traffic_steering_rules_by_id_with_http_info,
+ response_type=TrafficSteeringRules,
+ id=clean_traffic_steering_rule.id
+ )
+
+ # Verify
+ assert fetched_obj.id == clean_traffic_steering_rule.id
+ assert fetched_obj.name == clean_traffic_steering_rule.name
+
+
+def test_update_traffic_steering_rule(traffic_steering_rules_api, clean_traffic_steering_rule):
+ """
+ Test updating an existing traffic steering rule.
+ Equivalent to Go: Test_deployment_services_TrafficSteeringRulesAPIService_Update
+ """
+ # Prepare Update Payload with modified destination
+ update_payload = TrafficSteeringRules(
+ id=clean_traffic_steering_rule.id,
+ name=clean_traffic_steering_rule.name,
+ folder=TARGET_FOLDER,
+ service=["any"],
+ source=["any"],
+ destination=["10.0.0.0/8"],
+ action=TrafficSteeringRulesAction()
+ )
+
+ # Perform Update
+ updated_obj = perform(
+ traffic_steering_rules_api.update_traffic_steering_rules_by_id_with_http_info,
+ response_type=TrafficSteeringRules,
+ id=clean_traffic_steering_rule.id,
+ traffic_steering_rules=update_payload
+ )
+
+ # Verify
+ assert updated_obj.id == clean_traffic_steering_rule.id
+ assert updated_obj.name == clean_traffic_steering_rule.name
+ assert updated_obj.destination is not None
+ assert "10.0.0.0/8" in updated_obj.destination
+
+
+def test_list_traffic_steering_rules(traffic_steering_rules_api, clean_traffic_steering_rule):
+ """
+ Test listing traffic steering rules.
+ Equivalent to Go: Test_deployment_services_TrafficSteeringRulesAPIService_List
+ """
+ response = traffic_steering_rules_api.list_traffic_steering_rules(
+ folder=TARGET_FOLDER,
+ limit=10000
+ )
+
+ # Verify
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_traffic_steering_rule.name:
+ found = True
+ break
+ assert found is True, f"Created rule {clean_traffic_steering_rule.name} not found in list response"
+
+
+def test_fetch_traffic_steering_rules(traffic_steering_rules_api, clean_traffic_steering_rule):
+ """
+ Test fetching a single traffic steering rule by name using the fetch convenience method.
+ Equivalent to Go: Test_deployment_services_TrafficSteeringRulesAPIService_FetchTrafficSteeringRules
+ """
+ # Fetch by exact name
+ fetched_obj = traffic_steering_rules_api.fetch_traffic_steering_rules(
+ name=clean_traffic_steering_rule.name,
+ folder=TARGET_FOLDER
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found traffic_steering_rules '{clean_traffic_steering_rule.name}'"
+ assert fetched_obj.id == clean_traffic_steering_rule.id
+ assert fetched_obj.name == clean_traffic_steering_rule.name
+ logger.info(f"\n[SUCCESS] fetch_traffic_steering_rules found object: {fetched_obj.name}")
+
+ # Test fetching non-existent traffic_steering_rules (should return None)
+ not_found = traffic_steering_rules_api.fetch_traffic_steering_rules(
+ name="non-existent-traffic-steering-rules-xyz-12345",
+ folder=TARGET_FOLDER
+ )
+ assert not_found is None, "Should return None for non-existent traffic_steering_rules"
+ logger.info(f"\n[SUCCESS] fetch_traffic_steering_rules correctly returned None for non-existent traffic_steering_rules")
+
+
+def test_delete_traffic_steering_rule_by_id(traffic_steering_rules_api):
+ """
+ Test deleting a traffic steering rule.
+ Equivalent to Go: Test_deployment_services_TrafficSteeringRulesAPIService_DeleteByID
+ """
+ random_suffix = uuid.uuid4().hex[:6]
+ rule_name = f"test-tsr-delete-{random_suffix}"
+
+ payload = TrafficSteeringRules(
+ id="",
+ name=rule_name,
+ folder=TARGET_FOLDER,
+ service=["any"],
+ source=["any"],
+ action=TrafficSteeringRulesAction()
+ )
+
+ # Create
+ created_obj = perform(
+ traffic_steering_rules_api.create_traffic_steering_rules_with_http_info,
+ response_type=TrafficSteeringRules,
+ folder=TARGET_FOLDER,
+ traffic_steering_rules=payload
+ )
+
+ # Delete
+ traffic_steering_rules_api.delete_traffic_steering_rules_by_id(id=created_obj.id)
+
+ # Verify deletion (expect ObjectNotPresentError)
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ traffic_steering_rules_api.get_traffic_steering_rules_by_id(id=created_obj.id)
+ pytest.fail("Traffic steering rule should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ logger.info(f"Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/device_settings/__init__.py b/scm/device_settings/__init__.py
new file mode 100644
index 00000000..da3fb71c
--- /dev/null
+++ b/scm/device_settings/__init__.py
@@ -0,0 +1,142 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from scm.device_settings.api.authentication_settings_api import AuthenticationSettingsApi
+from scm.device_settings.api.content_id_settings_api import ContentIDSettingsApi
+from scm.device_settings.api.device_redistribution_collector_settings_api import DeviceRedistributionCollectorSettingsApi
+from scm.device_settings.api.general_settings_api import GeneralSettingsApi
+from scm.device_settings.api.high_availability_devices_api import HighAvailabilityDevicesApi
+from scm.device_settings.api.login_banner_settings_api import LoginBannerSettingsApi
+from scm.device_settings.api.management_interface_settings_api import ManagementInterfaceSettingsApi
+from scm.device_settings.api.service_route_settings_api import ServiceRouteSettingsApi
+from scm.device_settings.api.service_settings_api import ServiceSettingsApi
+from scm.device_settings.api.session_settings_api import SessionSettingsApi
+from scm.device_settings.api.session_timeouts_settings_api import SessionTimeoutsSettingsApi
+from scm.device_settings.api.tcp_settings_api import TCPSettingsApi
+from scm.device_settings.api.update_schedule_settings_api import UpdateScheduleSettingsApi
+from scm.device_settings.api.vpn_settings_api import VPNSettingsApi
+
+# import ApiClient
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.api_client import ApiClient
+from scm.device_settings.configuration import Configuration
+from scm.device_settings.exceptions import OpenApiException
+from scm.device_settings.exceptions import ApiTypeError
+from scm.device_settings.exceptions import ApiValueError
+from scm.device_settings.exceptions import ApiKeyError
+from scm.device_settings.exceptions import ApiAttributeError
+from scm.device_settings.exceptions import ApiException
+
+# import models into sdk package
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+from scm.device_settings.models.authentication_settings_authentication import AuthenticationSettingsAuthentication
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+from scm.device_settings.models.content_id_settings_content_id import ContentIdSettingsContentId
+from scm.device_settings.models.content_id_settings_content_id_application import ContentIdSettingsContentIdApplication
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+from scm.device_settings.models.device_redistribution_collector_redistribution_collector import DeviceRedistributionCollectorRedistributionCollector
+from scm.device_settings.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.device_settings.models.general_settings import GeneralSettings
+from scm.device_settings.models.general_settings_general import GeneralSettingsGeneral
+from scm.device_settings.models.general_settings_general_geo_location import GeneralSettingsGeneralGeoLocation
+from scm.device_settings.models.general_settings_general_setting import GeneralSettingsGeneralSetting
+from scm.device_settings.models.general_settings_general_setting_management import GeneralSettingsGeneralSettingManagement
+from scm.device_settings.models.generic_error import GenericError
+from scm.device_settings.models.ha_configurations import HaConfigurations
+from scm.device_settings.models.ha_configurations_group import HaConfigurationsGroup
+from scm.device_settings.models.ha_configurations_group_election_option import HaConfigurationsGroupElectionOption
+from scm.device_settings.models.ha_configurations_group_mode import HaConfigurationsGroupMode
+from scm.device_settings.models.ha_configurations_group_mode_active_passive import HaConfigurationsGroupModeActivePassive
+from scm.device_settings.models.ha_configurations_group_monitoring import HaConfigurationsGroupMonitoring
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring import HaConfigurationsGroupMonitoringLinkMonitoring
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring_link_group_inner import HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring import HaConfigurationsGroupMonitoringPathMonitoring
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group import HaConfigurationsGroupMonitoringPathMonitoringPathGroup
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner
+from scm.device_settings.models.ha_configurations_group_state_synchronization import HaConfigurationsGroupStateSynchronization
+from scm.device_settings.models.ha_configurations_group_state_synchronization_ha2_keep_alive import HaConfigurationsGroupStateSynchronizationHa2KeepAlive
+from scm.device_settings.models.ha_configurations_interface import HaConfigurationsInterface
+from scm.device_settings.models.ha_configurations_interface_ha1 import HaConfigurationsInterfaceHa1
+from scm.device_settings.models.ha_configurations_interface_ha1_backup import HaConfigurationsInterfaceHa1Backup
+from scm.device_settings.models.ha_configurations_interface_ha2 import HaConfigurationsInterfaceHa2
+from scm.device_settings.models.ha_configurations_interface_ha2_backup import HaConfigurationsInterfaceHa2Backup
+from scm.device_settings.models.ha_devices import HaDevices
+from scm.device_settings.models.ha_devices_ha_devices_inner import HaDevicesHaDevicesInner
+from scm.device_settings.models.list_ha_devices200_response import ListHADevices200Response
+from scm.device_settings.models.management_interface import ManagementInterface
+from scm.device_settings.models.management_interface_management_interface import ManagementInterfaceManagementInterface
+from scm.device_settings.models.management_interface_management_interface_mgmt_type import ManagementInterfaceManagementInterfaceMgmtType
+from scm.device_settings.models.management_interface_management_interface_mgmt_type_dhcp_client import ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient
+from scm.device_settings.models.management_interface_management_interface_permitted_ip_inner import ManagementInterfaceManagementInterfacePermittedIpInner
+from scm.device_settings.models.management_interface_management_interface_service import ManagementInterfaceManagementInterfaceService
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+from scm.device_settings.models.motd_banner_settings_motd_and_banner import MotdBannerSettingsMotdAndBanner
+from scm.device_settings.models.motd_color import MotdColor
+from scm.device_settings.models.service_route import ServiceRoute
+from scm.device_settings.models.service_route_route import ServiceRouteRoute
+from scm.device_settings.models.service_route_route_destination_inner import ServiceRouteRouteDestinationInner
+from scm.device_settings.models.service_route_route_destination_inner_source import ServiceRouteRouteDestinationInnerSource
+from scm.device_settings.models.service_route_route_service_inner import ServiceRouteRouteServiceInner
+from scm.device_settings.models.service_route_route_service_inner_source import ServiceRouteRouteServiceInnerSource
+from scm.device_settings.models.service_route_route_service_inner_source_v6 import ServiceRouteRouteServiceInnerSourceV6
+from scm.device_settings.models.service_settings import ServiceSettings
+from scm.device_settings.models.service_settings_services import ServiceSettingsServices
+from scm.device_settings.models.service_settings_services_dns_setting import ServiceSettingsServicesDnsSetting
+from scm.device_settings.models.service_settings_services_dns_setting_servers import ServiceSettingsServicesDnsSettingServers
+from scm.device_settings.models.service_settings_services_ntp_servers import ServiceSettingsServicesNtpServers
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server import ServiceSettingsServicesNtpServersPrimaryNtpServer
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5 import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5
+from scm.device_settings.models.session_settings import SessionSettings
+from scm.device_settings.models.session_settings_session_settings import SessionSettingsSessionSettings
+from scm.device_settings.models.session_settings_session_settings_config import SessionSettingsSessionSettingsConfig
+from scm.device_settings.models.session_settings_session_settings_icmpv6_rate_limit import SessionSettingsSessionSettingsIcmpv6RateLimit
+from scm.device_settings.models.session_settings_session_settings_jumbo_frame import SessionSettingsSessionSettingsJumboFrame
+from scm.device_settings.models.session_settings_session_settings_nat import SessionSettingsSessionSettingsNat
+from scm.device_settings.models.session_settings_session_settings_nat64 import SessionSettingsSessionSettingsNat64
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+from scm.device_settings.models.session_timeouts_session_timeouts import SessionTimeoutsSessionTimeouts
+from scm.device_settings.models.tcp_settings import TcpSettings
+from scm.device_settings.models.tcp_settings_tcp import TcpSettingsTcp
+from scm.device_settings.models.update_schedule import UpdateSchedule
+from scm.device_settings.models.update_schedule_update_schedule import UpdateScheduleUpdateSchedule
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus import UpdateScheduleUpdateScheduleAntiVirus
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring import UpdateScheduleUpdateScheduleAntiVirusRecurring
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_daily import UpdateScheduleUpdateScheduleAntiVirusRecurringDaily
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_hourly import UpdateScheduleUpdateScheduleAntiVirusRecurringHourly
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_weekly import UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly
+from scm.device_settings.models.update_schedule_update_schedule_threats import UpdateScheduleUpdateScheduleThreats
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring import UpdateScheduleUpdateScheduleThreatsRecurring
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_daily import UpdateScheduleUpdateScheduleThreatsRecurringDaily
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_every30_mins import UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_hourly import UpdateScheduleUpdateScheduleThreatsRecurringHourly
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_weekly import UpdateScheduleUpdateScheduleThreatsRecurringWeekly
+from scm.device_settings.models.update_schedule_update_schedule_wildfire import UpdateScheduleUpdateScheduleWildfire
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring import UpdateScheduleUpdateScheduleWildfireRecurring
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every15_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every30_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_hour import UpdateScheduleUpdateScheduleWildfireRecurringEveryHour
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_min import UpdateScheduleUpdateScheduleWildfireRecurringEveryMin
+from scm.device_settings.models.vpn_settings import VpnSettings
+from scm.device_settings.models.vpn_settings_vpn import VpnSettingsVpn
+from scm.device_settings.models.vpn_settings_vpn_ikev2 import VpnSettingsVpnIkev2
diff --git a/scm/device_settings/api/__init__.py b/scm/device_settings/api/__init__.py
new file mode 100644
index 00000000..61bdefab
--- /dev/null
+++ b/scm/device_settings/api/__init__.py
@@ -0,0 +1,18 @@
+# flake8: noqa
+
+# import apis into api package
+from scm.device_settings.api.authentication_settings_api import AuthenticationSettingsApi
+from scm.device_settings.api.content_id_settings_api import ContentIDSettingsApi
+from scm.device_settings.api.device_redistribution_collector_settings_api import DeviceRedistributionCollectorSettingsApi
+from scm.device_settings.api.general_settings_api import GeneralSettingsApi
+from scm.device_settings.api.high_availability_devices_api import HighAvailabilityDevicesApi
+from scm.device_settings.api.login_banner_settings_api import LoginBannerSettingsApi
+from scm.device_settings.api.management_interface_settings_api import ManagementInterfaceSettingsApi
+from scm.device_settings.api.service_route_settings_api import ServiceRouteSettingsApi
+from scm.device_settings.api.service_settings_api import ServiceSettingsApi
+from scm.device_settings.api.session_settings_api import SessionSettingsApi
+from scm.device_settings.api.session_timeouts_settings_api import SessionTimeoutsSettingsApi
+from scm.device_settings.api.tcp_settings_api import TCPSettingsApi
+from scm.device_settings.api.update_schedule_settings_api import UpdateScheduleSettingsApi
+from scm.device_settings.api.vpn_settings_api import VPNSettingsApi
+
diff --git a/scm/device_settings/api/authentication_settings_api.py b/scm/device_settings/api/authentication_settings_api.py
new file mode 100644
index 00000000..8d4aaaa9
--- /dev/null
+++ b/scm/device_settings/api/authentication_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AuthenticationSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_settings(
+ self,
+ authentication_settings: Optional[AuthenticationSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationSettings:
+ """Create authentication settings
+
+ Create new device authentication settings.
+
+ :param authentication_settings:
+ :type authentication_settings: AuthenticationSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_settings_serialize(
+ authentication_settings=authentication_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_settings_with_http_info(
+ self,
+ authentication_settings: Optional[AuthenticationSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationSettings]:
+ """Create authentication settings
+
+ Create new device authentication settings.
+
+ :param authentication_settings:
+ :type authentication_settings: AuthenticationSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_settings_serialize(
+ authentication_settings=authentication_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_settings_without_preload_content(
+ self,
+ authentication_settings: Optional[AuthenticationSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create authentication settings
+
+ Create new device authentication settings.
+
+ :param authentication_settings:
+ :type authentication_settings: AuthenticationSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_settings_serialize(
+ authentication_settings=authentication_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_authentication_settings_serialize(
+ self,
+ authentication_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_settings is not None:
+ _body_params = authentication_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/authentication-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete authentication settings
+
+ Delete the device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete authentication settings
+
+ Delete the device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete authentication settings
+
+ Delete the device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_authentication_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/authentication-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationSettings:
+ """Get existing authentication settings
+
+ Retrieve existing device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationSettings]:
+ """Get existing authentication settings
+
+ Retrieve existing device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing authentication settings
+
+ Retrieve existing device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_authentication_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[AuthenticationSettings]:
+ """List authentication settings
+
+ Retrieve a list of device authentication settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[AuthenticationSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[AuthenticationSettings]]:
+ """List authentication settings
+
+ Retrieve a list of device authentication settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[AuthenticationSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List authentication settings
+
+ Retrieve a list of device authentication settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[AuthenticationSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_authentication_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_settings: Optional[AuthenticationSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationSettings:
+ """Update authentication settings
+
+ Update the device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_settings:
+ :type authentication_settings: AuthenticationSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_settings_by_id_serialize(
+ id=id,
+ authentication_settings=authentication_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_settings: Optional[AuthenticationSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationSettings]:
+ """Update authentication settings
+
+ Update the device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_settings:
+ :type authentication_settings: AuthenticationSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_settings_by_id_serialize(
+ id=id,
+ authentication_settings=authentication_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_settings: Optional[AuthenticationSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update authentication settings
+
+ Update the device authentication settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_settings:
+ :type authentication_settings: AuthenticationSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_settings_by_id_serialize(
+ id=id,
+ authentication_settings=authentication_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_authentication_settings_by_id_serialize(
+ self,
+ id,
+ authentication_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_settings is not None:
+ _body_params = authentication_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/authentication-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/content_id_settings_api.py b/scm/device_settings/api/content_id_settings_api.py
new file mode 100644
index 00000000..a3272d4d
--- /dev/null
+++ b/scm/device_settings/api/content_id_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ContentIDSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_content_id_settings(
+ self,
+ content_id_settings: Optional[ContentIdSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ContentIdSettings:
+ """Create Content-ID settings
+
+ Create new Content-ID settings.
+
+ :param content_id_settings:
+ :type content_id_settings: ContentIdSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_content_id_settings_serialize(
+ content_id_settings=content_id_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_content_id_settings_with_http_info(
+ self,
+ content_id_settings: Optional[ContentIdSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ContentIdSettings]:
+ """Create Content-ID settings
+
+ Create new Content-ID settings.
+
+ :param content_id_settings:
+ :type content_id_settings: ContentIdSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_content_id_settings_serialize(
+ content_id_settings=content_id_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_content_id_settings_without_preload_content(
+ self,
+ content_id_settings: Optional[ContentIdSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create Content-ID settings
+
+ Create new Content-ID settings.
+
+ :param content_id_settings:
+ :type content_id_settings: ContentIdSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_content_id_settings_serialize(
+ content_id_settings=content_id_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_content_id_settings_serialize(
+ self,
+ content_id_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if content_id_settings is not None:
+ _body_params = content_id_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/content-id-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_content_id_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete Content-ID settings
+
+ Delete the Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_content_id_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_content_id_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete Content-ID settings
+
+ Delete the Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_content_id_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_content_id_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete Content-ID settings
+
+ Delete the Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_content_id_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_content_id_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/content-id-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_content_id_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ContentIdSettings:
+ """Get existing Content-ID settings
+
+ Retrieve existing Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_content_id_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_content_id_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ContentIdSettings]:
+ """Get existing Content-ID settings
+
+ Retrieve existing Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_content_id_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_content_id_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing Content-ID settings
+
+ Retrieve existing Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_content_id_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_content_id_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/content-id-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_content_id_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[ContentIdSettings]:
+ """List Content-ID settings
+
+ Retrieve a list of Content-ID settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_content_id_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ContentIdSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_content_id_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[ContentIdSettings]]:
+ """List Content-ID settings
+
+ Retrieve a list of Content-ID settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_content_id_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ContentIdSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_content_id_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List Content-ID settings
+
+ Retrieve a list of Content-ID settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_content_id_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ContentIdSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_content_id_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/content-id-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_content_id_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ content_id_settings: Annotated[Optional[ContentIdSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ContentIdSettings:
+ """Update Content-ID settings
+
+ Update the Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param content_id_settings: OK
+ :type content_id_settings: ContentIdSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_content_id_settings_by_id_serialize(
+ id=id,
+ content_id_settings=content_id_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_content_id_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ content_id_settings: Annotated[Optional[ContentIdSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ContentIdSettings]:
+ """Update Content-ID settings
+
+ Update the Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param content_id_settings: OK
+ :type content_id_settings: ContentIdSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_content_id_settings_by_id_serialize(
+ id=id,
+ content_id_settings=content_id_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_content_id_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ content_id_settings: Annotated[Optional[ContentIdSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update Content-ID settings
+
+ Update the Content-ID settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param content_id_settings: OK
+ :type content_id_settings: ContentIdSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_content_id_settings_by_id_serialize(
+ id=id,
+ content_id_settings=content_id_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ContentIdSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_content_id_settings_by_id_serialize(
+ self,
+ id,
+ content_id_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if content_id_settings is not None:
+ _body_params = content_id_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/content-id-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/device_redistribution_collector_settings_api.py b/scm/device_settings/api/device_redistribution_collector_settings_api.py
new file mode 100644
index 00000000..90e4a8dd
--- /dev/null
+++ b/scm/device_settings/api/device_redistribution_collector_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class DeviceRedistributionCollectorSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_device_redistribution_collector_settings(
+ self,
+ device_redistribution_collector: Optional[DeviceRedistributionCollector] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DeviceRedistributionCollector:
+ """Create device redistribution collector settings
+
+ Create new device redistribution collector settings.
+
+ :param device_redistribution_collector:
+ :type device_redistribution_collector: DeviceRedistributionCollector
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_device_redistribution_collector_settings_serialize(
+ device_redistribution_collector=device_redistribution_collector,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_device_redistribution_collector_settings_with_http_info(
+ self,
+ device_redistribution_collector: Optional[DeviceRedistributionCollector] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DeviceRedistributionCollector]:
+ """Create device redistribution collector settings
+
+ Create new device redistribution collector settings.
+
+ :param device_redistribution_collector:
+ :type device_redistribution_collector: DeviceRedistributionCollector
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_device_redistribution_collector_settings_serialize(
+ device_redistribution_collector=device_redistribution_collector,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_device_redistribution_collector_settings_without_preload_content(
+ self,
+ device_redistribution_collector: Optional[DeviceRedistributionCollector] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create device redistribution collector settings
+
+ Create new device redistribution collector settings.
+
+ :param device_redistribution_collector:
+ :type device_redistribution_collector: DeviceRedistributionCollector
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_device_redistribution_collector_settings_serialize(
+ device_redistribution_collector=device_redistribution_collector,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_device_redistribution_collector_settings_serialize(
+ self,
+ device_redistribution_collector,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if device_redistribution_collector is not None:
+ _body_params = device_redistribution_collector
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/device-redistribution-collector',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_device_redistribution_collector_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete device redistribution collector settings
+
+ Delete the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_device_redistribution_collector_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete device redistribution collector settings
+
+ Delete the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_device_redistribution_collector_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete device redistribution collector settings
+
+ Delete the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_device_redistribution_collector_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/device-redistribution-collector/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_device_redistribution_collector_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DeviceRedistributionCollector:
+ """Get existing device redistribution collector settings
+
+ Retrieve existing device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_device_redistribution_collector_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DeviceRedistributionCollector]:
+ """Get existing device redistribution collector settings
+
+ Retrieve existing device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_device_redistribution_collector_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing device redistribution collector settings
+
+ Retrieve existing device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_device_redistribution_collector_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/device-redistribution-collector/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_device_redistribution_collector_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[DeviceRedistributionCollector]:
+ """List device redistribution collector settings
+
+ Retrieve a list of device redistribution collector settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_device_redistribution_collector_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[DeviceRedistributionCollector]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_device_redistribution_collector_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[DeviceRedistributionCollector]]:
+ """List device redistribution collector settings
+
+ Retrieve a list of device redistribution collector settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_device_redistribution_collector_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[DeviceRedistributionCollector]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_device_redistribution_collector_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List device redistribution collector settings
+
+ Retrieve a list of device redistribution collector settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_device_redistribution_collector_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[DeviceRedistributionCollector]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_device_redistribution_collector_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/device-redistribution-collector',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_device_redistribution_collector_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ device_redistribution_collector: Annotated[Optional[DeviceRedistributionCollector], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DeviceRedistributionCollector:
+ """Update device redistribution collector settings
+
+ Update the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param device_redistribution_collector: OK
+ :type device_redistribution_collector: DeviceRedistributionCollector
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ device_redistribution_collector=device_redistribution_collector,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_device_redistribution_collector_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ device_redistribution_collector: Annotated[Optional[DeviceRedistributionCollector], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DeviceRedistributionCollector]:
+ """Update device redistribution collector settings
+
+ Update the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param device_redistribution_collector: OK
+ :type device_redistribution_collector: DeviceRedistributionCollector
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ device_redistribution_collector=device_redistribution_collector,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_device_redistribution_collector_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ device_redistribution_collector: Annotated[Optional[DeviceRedistributionCollector], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update device redistribution collector settings
+
+ Update the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param device_redistribution_collector: OK
+ :type device_redistribution_collector: DeviceRedistributionCollector
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_device_redistribution_collector_settings_by_id_serialize(
+ id=id,
+ device_redistribution_collector=device_redistribution_collector,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DeviceRedistributionCollector",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_device_redistribution_collector_settings_by_id_serialize(
+ self,
+ id,
+ device_redistribution_collector,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if device_redistribution_collector is not None:
+ _body_params = device_redistribution_collector
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/device-redistribution-collector/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/general_settings_api.py b/scm/device_settings/api/general_settings_api.py
new file mode 100644
index 00000000..6196bfd2
--- /dev/null
+++ b/scm/device_settings/api/general_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.general_settings import GeneralSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class GeneralSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_general_settings(
+ self,
+ general_settings: Optional[GeneralSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GeneralSettings:
+ """Create general settings
+
+ Create new general settings.
+
+ :param general_settings:
+ :type general_settings: GeneralSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_general_settings_serialize(
+ general_settings=general_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_general_settings_with_http_info(
+ self,
+ general_settings: Optional[GeneralSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GeneralSettings]:
+ """Create general settings
+
+ Create new general settings.
+
+ :param general_settings:
+ :type general_settings: GeneralSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_general_settings_serialize(
+ general_settings=general_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_general_settings_without_preload_content(
+ self,
+ general_settings: Optional[GeneralSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create general settings
+
+ Create new general settings.
+
+ :param general_settings:
+ :type general_settings: GeneralSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_general_settings_serialize(
+ general_settings=general_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_general_settings_serialize(
+ self,
+ general_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if general_settings is not None:
+ _body_params = general_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/general-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_general_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete general settings
+
+ Delete the general settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_general_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_general_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete general settings
+
+ Delete the general settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_general_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_general_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete general settings
+
+ Delete the general settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_general_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_general_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/general-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_general_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GeneralSettings:
+ """Get existing general settings
+
+ Retrieve existing general settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_general_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_general_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GeneralSettings]:
+ """Get existing general settings
+
+ Retrieve existing general settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_general_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_general_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing general settings
+
+ Retrieve existing general settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_general_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_general_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/general-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_general_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[GeneralSettings]:
+ """List general settings
+
+ Retrieve a list of general settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_general_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[GeneralSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_general_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[GeneralSettings]]:
+ """List general settings
+
+ Retrieve a list of general settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_general_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[GeneralSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_general_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List general settings
+
+ Retrieve a list of general settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_general_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[GeneralSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_general_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/general-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_general_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ general_settings: Annotated[Optional[GeneralSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GeneralSettings:
+ """Update general settings
+
+ Update the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param general_settings: OK
+ :type general_settings: GeneralSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_general_settings_by_id_serialize(
+ id=id,
+ general_settings=general_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_general_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ general_settings: Annotated[Optional[GeneralSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GeneralSettings]:
+ """Update general settings
+
+ Update the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param general_settings: OK
+ :type general_settings: GeneralSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_general_settings_by_id_serialize(
+ id=id,
+ general_settings=general_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_general_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ general_settings: Annotated[Optional[GeneralSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update general settings
+
+ Update the device redistribution collector settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param general_settings: OK
+ :type general_settings: GeneralSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_general_settings_by_id_serialize(
+ id=id,
+ general_settings=general_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GeneralSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_general_settings_by_id_serialize(
+ self,
+ id,
+ general_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if general_settings is not None:
+ _body_params = general_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/general-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/high_availability_devices_api.py b/scm/device_settings/api/high_availability_devices_api.py
new file mode 100644
index 00000000..0a8e6b95
--- /dev/null
+++ b/scm/device_settings/api/high_availability_devices_api.py
@@ -0,0 +1,354 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.list_ha_devices200_response import ListHADevices200Response
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class HighAvailabilityDevicesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def list_ha_devices(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ListHADevices200Response:
+ """List high availability devices
+
+ Retrieve a list of high availability devices.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ha_devices_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ListHADevices200Response",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_ha_devices_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ListHADevices200Response]:
+ """List high availability devices
+
+ Retrieve a list of high availability devices.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ha_devices_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ListHADevices200Response",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_ha_devices_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List high availability devices
+
+ Retrieve a list of high availability devices.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ha_devices_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ListHADevices200Response",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_ha_devices_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ha-devices',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/login_banner_settings_api.py b/scm/device_settings/api/login_banner_settings_api.py
new file mode 100644
index 00000000..0669aeeb
--- /dev/null
+++ b/scm/device_settings/api/login_banner_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LoginBannerSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_login_banner_settings(
+ self,
+ motd_banner_settings: Optional[MotdBannerSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> MotdBannerSettings:
+ """Create login banner settings
+
+ Create new login banner settings.
+
+ :param motd_banner_settings:
+ :type motd_banner_settings: MotdBannerSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_login_banner_settings_serialize(
+ motd_banner_settings=motd_banner_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_login_banner_settings_with_http_info(
+ self,
+ motd_banner_settings: Optional[MotdBannerSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[MotdBannerSettings]:
+ """Create login banner settings
+
+ Create new login banner settings.
+
+ :param motd_banner_settings:
+ :type motd_banner_settings: MotdBannerSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_login_banner_settings_serialize(
+ motd_banner_settings=motd_banner_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_login_banner_settings_without_preload_content(
+ self,
+ motd_banner_settings: Optional[MotdBannerSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create login banner settings
+
+ Create new login banner settings.
+
+ :param motd_banner_settings:
+ :type motd_banner_settings: MotdBannerSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_login_banner_settings_serialize(
+ motd_banner_settings=motd_banner_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_login_banner_settings_serialize(
+ self,
+ motd_banner_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if motd_banner_settings is not None:
+ _body_params = motd_banner_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/motd-banner-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_login_banner_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete login banner settings
+
+ Delete the login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_login_banner_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_login_banner_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete login banner settings
+
+ Delete the login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_login_banner_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_login_banner_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete login banner settings
+
+ Delete the login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_login_banner_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_login_banner_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/motd-banner-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_login_banner_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> MotdBannerSettings:
+ """Get existing login banner settings
+
+ Retrieve existing login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_login_banner_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_login_banner_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[MotdBannerSettings]:
+ """Get existing login banner settings
+
+ Retrieve existing login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_login_banner_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_login_banner_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing login banner settings
+
+ Retrieve existing login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_login_banner_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_login_banner_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/motd-banner-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_login_banner_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[MotdBannerSettings]:
+ """List login banner settings
+
+ Retrieve a list of login banner settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_login_banner_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[MotdBannerSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_login_banner_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[MotdBannerSettings]]:
+ """List login banner settings
+
+ Retrieve a list of login banner settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_login_banner_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[MotdBannerSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_login_banner_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List login banner settings
+
+ Retrieve a list of login banner settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_login_banner_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[MotdBannerSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_login_banner_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/motd-banner-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_login_banner_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ motd_banner_settings: Annotated[Optional[MotdBannerSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> MotdBannerSettings:
+ """Update login banner settings
+
+ Update the login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param motd_banner_settings: OK
+ :type motd_banner_settings: MotdBannerSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_login_banner_settings_by_id_serialize(
+ id=id,
+ motd_banner_settings=motd_banner_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_login_banner_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ motd_banner_settings: Annotated[Optional[MotdBannerSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[MotdBannerSettings]:
+ """Update login banner settings
+
+ Update the login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param motd_banner_settings: OK
+ :type motd_banner_settings: MotdBannerSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_login_banner_settings_by_id_serialize(
+ id=id,
+ motd_banner_settings=motd_banner_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_login_banner_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ motd_banner_settings: Annotated[Optional[MotdBannerSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update login banner settings
+
+ Update the login banner settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param motd_banner_settings: OK
+ :type motd_banner_settings: MotdBannerSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_login_banner_settings_by_id_serialize(
+ id=id,
+ motd_banner_settings=motd_banner_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MotdBannerSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_login_banner_settings_by_id_serialize(
+ self,
+ id,
+ motd_banner_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if motd_banner_settings is not None:
+ _body_params = motd_banner_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/motd-banner-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/management_interface_settings_api.py b/scm/device_settings/api/management_interface_settings_api.py
new file mode 100644
index 00000000..91d4a134
--- /dev/null
+++ b/scm/device_settings/api/management_interface_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.management_interface import ManagementInterface
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ManagementInterfaceSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_management_interface_settings(
+ self,
+ management_interface: Optional[ManagementInterface] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ManagementInterface:
+ """Create management interface settings
+
+ Create new management interface settings.
+
+ :param management_interface:
+ :type management_interface: ManagementInterface
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_management_interface_settings_serialize(
+ management_interface=management_interface,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_management_interface_settings_with_http_info(
+ self,
+ management_interface: Optional[ManagementInterface] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ManagementInterface]:
+ """Create management interface settings
+
+ Create new management interface settings.
+
+ :param management_interface:
+ :type management_interface: ManagementInterface
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_management_interface_settings_serialize(
+ management_interface=management_interface,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_management_interface_settings_without_preload_content(
+ self,
+ management_interface: Optional[ManagementInterface] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create management interface settings
+
+ Create new management interface settings.
+
+ :param management_interface:
+ :type management_interface: ManagementInterface
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_management_interface_settings_serialize(
+ management_interface=management_interface,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_management_interface_settings_serialize(
+ self,
+ management_interface,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if management_interface is not None:
+ _body_params = management_interface
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/management-interface',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_management_interface_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete management interface settings
+
+ Delete the management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_management_interface_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_management_interface_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete management interface settings
+
+ Delete the management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_management_interface_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_management_interface_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete management interface settings
+
+ Delete the management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_management_interface_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_management_interface_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/management-interface/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_management_interface_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ManagementInterface:
+ """Get existing management interface settings
+
+ Retrieve existing management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_management_interface_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_management_interface_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ManagementInterface]:
+ """Get existing management interface settings
+
+ Retrieve existing management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_management_interface_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_management_interface_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing management interface settings
+
+ Retrieve existing management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_management_interface_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_management_interface_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/management-interface/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_management_interface_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[ManagementInterface]:
+ """List management interface settings
+
+ Retrieve a list of management interface settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_management_interface_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ManagementInterface]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_management_interface_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[ManagementInterface]]:
+ """List management interface settings
+
+ Retrieve a list of management interface settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_management_interface_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ManagementInterface]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_management_interface_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List management interface settings
+
+ Retrieve a list of management interface settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_management_interface_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ManagementInterface]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_management_interface_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/management-interface',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_management_interface_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ management_interface: Annotated[Optional[ManagementInterface], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ManagementInterface:
+ """Update management interface settings
+
+ Update the management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param management_interface: OK
+ :type management_interface: ManagementInterface
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_management_interface_settings_by_id_serialize(
+ id=id,
+ management_interface=management_interface,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_management_interface_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ management_interface: Annotated[Optional[ManagementInterface], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ManagementInterface]:
+ """Update management interface settings
+
+ Update the management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param management_interface: OK
+ :type management_interface: ManagementInterface
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_management_interface_settings_by_id_serialize(
+ id=id,
+ management_interface=management_interface,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_management_interface_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ management_interface: Annotated[Optional[ManagementInterface], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update management interface settings
+
+ Update the management interface settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param management_interface: OK
+ :type management_interface: ManagementInterface
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_management_interface_settings_by_id_serialize(
+ id=id,
+ management_interface=management_interface,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ManagementInterface",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_management_interface_settings_by_id_serialize(
+ self,
+ id,
+ management_interface,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if management_interface is not None:
+ _body_params = management_interface
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/management-interface/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/service_route_settings_api.py b/scm/device_settings/api/service_route_settings_api.py
new file mode 100644
index 00000000..8c1062a2
--- /dev/null
+++ b/scm/device_settings/api/service_route_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.service_route import ServiceRoute
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ServiceRouteSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_route_settings(
+ self,
+ service_route: Optional[ServiceRoute] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceRoute:
+ """Create service route settings
+
+ Create new service route settings.
+
+ :param service_route:
+ :type service_route: ServiceRoute
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_route_settings_serialize(
+ service_route=service_route,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_route_settings_with_http_info(
+ self,
+ service_route: Optional[ServiceRoute] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceRoute]:
+ """Create service route settings
+
+ Create new service route settings.
+
+ :param service_route:
+ :type service_route: ServiceRoute
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_route_settings_serialize(
+ service_route=service_route,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_route_settings_without_preload_content(
+ self,
+ service_route: Optional[ServiceRoute] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create service route settings
+
+ Create new service route settings.
+
+ :param service_route:
+ :type service_route: ServiceRoute
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_route_settings_serialize(
+ service_route=service_route,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_service_route_settings_serialize(
+ self,
+ service_route,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_route is not None:
+ _body_params = service_route
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/service-route',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_route_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete service route settings
+
+ Delete the service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_route_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_route_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete service route settings
+
+ Delete the service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_route_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_route_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete service route settings
+
+ Delete the service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_route_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_service_route_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/service-route/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_route_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceRoute:
+ """Get existing service route settings
+
+ Retrieve existing service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_route_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_route_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceRoute]:
+ """Get existing service route settings
+
+ Retrieve existing service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_route_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_route_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing service route settings
+
+ Retrieve existing service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_route_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_service_route_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-route/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_route_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[ServiceRoute]:
+ """List service route settings
+
+ Retrieve a list of service route settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_route_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ServiceRoute]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_route_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[ServiceRoute]]:
+ """List service route settings
+
+ Retrieve a list of service route settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_route_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ServiceRoute]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_route_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List service route settings
+
+ Retrieve a list of service route settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_route_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ServiceRoute]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_service_route_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-route',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_route_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_route: Annotated[Optional[ServiceRoute], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceRoute:
+ """Update service route settings
+
+ Update the service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_route: OK
+ :type service_route: ServiceRoute
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_route_settings_by_id_serialize(
+ id=id,
+ service_route=service_route,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_route_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_route: Annotated[Optional[ServiceRoute], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceRoute]:
+ """Update service route settings
+
+ Update the service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_route: OK
+ :type service_route: ServiceRoute
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_route_settings_by_id_serialize(
+ id=id,
+ service_route=service_route,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_route_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_route: Annotated[Optional[ServiceRoute], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update service route settings
+
+ Update the service route settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_route: OK
+ :type service_route: ServiceRoute
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_route_settings_by_id_serialize(
+ id=id,
+ service_route=service_route,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceRoute",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_service_route_settings_by_id_serialize(
+ self,
+ id,
+ service_route,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_route is not None:
+ _body_params = service_route
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/service-route/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/service_settings_api.py b/scm/device_settings/api/service_settings_api.py
new file mode 100644
index 00000000..c5c0715f
--- /dev/null
+++ b/scm/device_settings/api/service_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.service_settings import ServiceSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ServiceSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_settings(
+ self,
+ service_settings: Optional[ServiceSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceSettings:
+ """Create service settings
+
+ Create new service settings.
+
+ :param service_settings:
+ :type service_settings: ServiceSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_settings_serialize(
+ service_settings=service_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_settings_with_http_info(
+ self,
+ service_settings: Optional[ServiceSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceSettings]:
+ """Create service settings
+
+ Create new service settings.
+
+ :param service_settings:
+ :type service_settings: ServiceSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_settings_serialize(
+ service_settings=service_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_service_settings_without_preload_content(
+ self,
+ service_settings: Optional[ServiceSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create service settings
+
+ Create new service settings.
+
+ :param service_settings:
+ :type service_settings: ServiceSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_service_settings_serialize(
+ service_settings=service_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_service_settings_serialize(
+ self,
+ service_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_settings is not None:
+ _body_params = service_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/service-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete service settings
+
+ Delete the service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete service settings
+
+ Delete the service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_service_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete service settings
+
+ Delete the service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_service_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_service_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/service-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceSettings:
+ """Get existing service settings
+
+ Retrieve existing service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceSettings]:
+ """Get existing service settings
+
+ Retrieve existing service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_service_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing service settings
+
+ Retrieve existing service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_service_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_service_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[ServiceSettings]:
+ """List service settings
+
+ Retrieve a list of service settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ServiceSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[ServiceSettings]]:
+ """List service settings
+
+ Retrieve a list of service settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ServiceSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_service_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List service settings
+
+ Retrieve a list of service settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_service_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[ServiceSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_service_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/service-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_settings: Annotated[Optional[ServiceSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ServiceSettings:
+ """Update service settings
+
+ Update the service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_settings: OK
+ :type service_settings: ServiceSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_settings_by_id_serialize(
+ id=id,
+ service_settings=service_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_settings: Annotated[Optional[ServiceSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ServiceSettings]:
+ """Update service settings
+
+ Update the service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_settings: OK
+ :type service_settings: ServiceSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_settings_by_id_serialize(
+ id=id,
+ service_settings=service_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_service_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ service_settings: Annotated[Optional[ServiceSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update service settings
+
+ Update the service settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param service_settings: OK
+ :type service_settings: ServiceSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_service_settings_by_id_serialize(
+ id=id,
+ service_settings=service_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ServiceSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_service_settings_by_id_serialize(
+ self,
+ id,
+ service_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if service_settings is not None:
+ _body_params = service_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/service-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/session_settings_api.py b/scm/device_settings/api/session_settings_api.py
new file mode 100644
index 00000000..abdd321d
--- /dev/null
+++ b/scm/device_settings/api/session_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.session_settings import SessionSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SessionSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_session_settings(
+ self,
+ session_settings: Optional[SessionSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SessionSettings:
+ """Create session settings
+
+ Create new session settings.
+
+ :param session_settings:
+ :type session_settings: SessionSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_session_settings_serialize(
+ session_settings=session_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_session_settings_with_http_info(
+ self,
+ session_settings: Optional[SessionSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SessionSettings]:
+ """Create session settings
+
+ Create new session settings.
+
+ :param session_settings:
+ :type session_settings: SessionSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_session_settings_serialize(
+ session_settings=session_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_session_settings_without_preload_content(
+ self,
+ session_settings: Optional[SessionSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create session settings
+
+ Create new session settings.
+
+ :param session_settings:
+ :type session_settings: SessionSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_session_settings_serialize(
+ session_settings=session_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_session_settings_serialize(
+ self,
+ session_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if session_settings is not None:
+ _body_params = session_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/session-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_session_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete session settings
+
+ Delete the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_session_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_session_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete session settings
+
+ Delete the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_session_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_session_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete session settings
+
+ Delete the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_session_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_session_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/session-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_session_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SessionSettings:
+ """Get existing session settings
+
+ Retrieve existing session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_session_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_session_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SessionSettings]:
+ """Get existing session settings
+
+ Retrieve existing session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_session_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_session_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing session settings
+
+ Retrieve existing session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_session_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_session_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/session-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_session_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[SessionSettings]:
+ """List session settings
+
+ Retrieve a list of session settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_session_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SessionSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_session_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[SessionSettings]]:
+ """List session settings
+
+ Retrieve a list of session settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_session_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SessionSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_session_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List session settings
+
+ Retrieve a list of session settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_session_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SessionSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_session_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/session-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_session_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ session_settings: Annotated[Optional[SessionSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SessionSettings:
+ """Update session settings
+
+ Update the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param session_settings: OK
+ :type session_settings: SessionSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_session_settings_by_id_serialize(
+ id=id,
+ session_settings=session_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_session_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ session_settings: Annotated[Optional[SessionSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SessionSettings]:
+ """Update session settings
+
+ Update the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param session_settings: OK
+ :type session_settings: SessionSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_session_settings_by_id_serialize(
+ id=id,
+ session_settings=session_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_session_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ session_settings: Annotated[Optional[SessionSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update session settings
+
+ Update the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param session_settings: OK
+ :type session_settings: SessionSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_session_settings_by_id_serialize(
+ id=id,
+ session_settings=session_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_session_settings_by_id_serialize(
+ self,
+ id,
+ session_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if session_settings is not None:
+ _body_params = session_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/session-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/session_timeouts_settings_api.py b/scm/device_settings/api/session_timeouts_settings_api.py
new file mode 100644
index 00000000..0c7b4d1f
--- /dev/null
+++ b/scm/device_settings/api/session_timeouts_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SessionTimeoutsSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_session_timeouts_settings(
+ self,
+ session_timeouts: Optional[SessionTimeouts] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SessionTimeouts:
+ """Create session timeouts settings
+
+ Create new session timeouts settings.
+
+ :param session_timeouts:
+ :type session_timeouts: SessionTimeouts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_session_timeouts_settings_serialize(
+ session_timeouts=session_timeouts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_session_timeouts_settings_with_http_info(
+ self,
+ session_timeouts: Optional[SessionTimeouts] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SessionTimeouts]:
+ """Create session timeouts settings
+
+ Create new session timeouts settings.
+
+ :param session_timeouts:
+ :type session_timeouts: SessionTimeouts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_session_timeouts_settings_serialize(
+ session_timeouts=session_timeouts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_session_timeouts_settings_without_preload_content(
+ self,
+ session_timeouts: Optional[SessionTimeouts] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create session timeouts settings
+
+ Create new session timeouts settings.
+
+ :param session_timeouts:
+ :type session_timeouts: SessionTimeouts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_session_timeouts_settings_serialize(
+ session_timeouts=session_timeouts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_session_timeouts_settings_serialize(
+ self,
+ session_timeouts,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if session_timeouts is not None:
+ _body_params = session_timeouts
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/session-timeouts',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_session_timeouts_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete session settings
+
+ Delete the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_session_timeouts_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_session_timeouts_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete session settings
+
+ Delete the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_session_timeouts_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_session_timeouts_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete session settings
+
+ Delete the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_session_timeouts_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_session_timeouts_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/session-timeouts/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_session_timeouts_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SessionTimeouts:
+ """Get existing session settings
+
+ Retrieve existing session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_session_timeouts_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_session_timeouts_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SessionTimeouts]:
+ """Get existing session settings
+
+ Retrieve existing session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_session_timeouts_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_session_timeouts_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing session settings
+
+ Retrieve existing session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_session_timeouts_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_session_timeouts_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/session-timeouts/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_session_timeouts_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[SessionTimeouts]:
+ """List session timeouts settings
+
+ Retrieve a list of session timeouts settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_session_timeouts_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SessionTimeouts]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_session_timeouts_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[SessionTimeouts]]:
+ """List session timeouts settings
+
+ Retrieve a list of session timeouts settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_session_timeouts_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SessionTimeouts]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_session_timeouts_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List session timeouts settings
+
+ Retrieve a list of session timeouts settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_session_timeouts_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[SessionTimeouts]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_session_timeouts_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/session-timeouts',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_session_timeouts_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ session_timeouts: Annotated[Optional[SessionTimeouts], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SessionTimeouts:
+ """Update session settings
+
+ Update the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param session_timeouts: OK
+ :type session_timeouts: SessionTimeouts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_session_timeouts_settings_by_id_serialize(
+ id=id,
+ session_timeouts=session_timeouts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_session_timeouts_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ session_timeouts: Annotated[Optional[SessionTimeouts], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SessionTimeouts]:
+ """Update session settings
+
+ Update the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param session_timeouts: OK
+ :type session_timeouts: SessionTimeouts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_session_timeouts_settings_by_id_serialize(
+ id=id,
+ session_timeouts=session_timeouts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_session_timeouts_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ session_timeouts: Annotated[Optional[SessionTimeouts], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update session settings
+
+ Update the session settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param session_timeouts: OK
+ :type session_timeouts: SessionTimeouts
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_session_timeouts_settings_by_id_serialize(
+ id=id,
+ session_timeouts=session_timeouts,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SessionTimeouts",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_session_timeouts_settings_by_id_serialize(
+ self,
+ id,
+ session_timeouts,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if session_timeouts is not None:
+ _body_params = session_timeouts
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/session-timeouts/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/tcp_settings_api.py b/scm/device_settings/api/tcp_settings_api.py
new file mode 100644
index 00000000..64c2f7b5
--- /dev/null
+++ b/scm/device_settings/api/tcp_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.tcp_settings import TcpSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TCPSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_tcp_settings(
+ self,
+ tcp_settings: Optional[TcpSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TcpSettings:
+ """Create TCP settings
+
+ Create new TCP settings.
+
+ :param tcp_settings:
+ :type tcp_settings: TcpSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tcp_settings_serialize(
+ tcp_settings=tcp_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_tcp_settings_with_http_info(
+ self,
+ tcp_settings: Optional[TcpSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TcpSettings]:
+ """Create TCP settings
+
+ Create new TCP settings.
+
+ :param tcp_settings:
+ :type tcp_settings: TcpSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tcp_settings_serialize(
+ tcp_settings=tcp_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_tcp_settings_without_preload_content(
+ self,
+ tcp_settings: Optional[TcpSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create TCP settings
+
+ Create new TCP settings.
+
+ :param tcp_settings:
+ :type tcp_settings: TcpSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tcp_settings_serialize(
+ tcp_settings=tcp_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_tcp_settings_serialize(
+ self,
+ tcp_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tcp_settings is not None:
+ _body_params = tcp_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/tcp-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tcp_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete TCP settings
+
+ Delete the TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tcp_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tcp_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete TCP settings
+
+ Delete the TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tcp_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tcp_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete TCP settings
+
+ Delete the TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tcp_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_tcp_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/tcp-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_tcp_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TcpSettings:
+ """Get existing TCP settings
+
+ Retrieve existing TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tcp_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_tcp_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TcpSettings]:
+ """Get existing TCP settings
+
+ Retrieve existing TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tcp_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_tcp_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing TCP settings
+
+ Retrieve existing TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tcp_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_tcp_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tcp-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_tcp_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[TcpSettings]:
+ """List TCP settings
+
+ Retrieve a list of TCP settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tcp_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[TcpSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_tcp_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[TcpSettings]]:
+ """List TCP settings
+
+ Retrieve a list of TCP settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tcp_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[TcpSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_tcp_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List TCP settings
+
+ Retrieve a list of TCP settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tcp_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[TcpSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_tcp_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tcp-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_tcp_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tcp_settings: Annotated[Optional[TcpSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TcpSettings:
+ """Update TCP settings
+
+ Update the TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tcp_settings: OK
+ :type tcp_settings: TcpSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tcp_settings_by_id_serialize(
+ id=id,
+ tcp_settings=tcp_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_tcp_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tcp_settings: Annotated[Optional[TcpSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TcpSettings]:
+ """Update TCP settings
+
+ Update the TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tcp_settings: OK
+ :type tcp_settings: TcpSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tcp_settings_by_id_serialize(
+ id=id,
+ tcp_settings=tcp_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_tcp_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tcp_settings: Annotated[Optional[TcpSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update TCP settings
+
+ Update the TCP settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tcp_settings: OK
+ :type tcp_settings: TcpSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tcp_settings_by_id_serialize(
+ id=id,
+ tcp_settings=tcp_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TcpSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_tcp_settings_by_id_serialize(
+ self,
+ id,
+ tcp_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tcp_settings is not None:
+ _body_params = tcp_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/tcp-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/update_schedule_settings_api.py b/scm/device_settings/api/update_schedule_settings_api.py
new file mode 100644
index 00000000..0e817baa
--- /dev/null
+++ b/scm/device_settings/api/update_schedule_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.update_schedule import UpdateSchedule
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class UpdateScheduleSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_update_schedule_settings(
+ self,
+ update_schedule: Optional[UpdateSchedule] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> UpdateSchedule:
+ """Create update schedule settings
+
+ Create new update schedule settings.
+
+ :param update_schedule:
+ :type update_schedule: UpdateSchedule
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_update_schedule_settings_serialize(
+ update_schedule=update_schedule,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_update_schedule_settings_with_http_info(
+ self,
+ update_schedule: Optional[UpdateSchedule] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[UpdateSchedule]:
+ """Create update schedule settings
+
+ Create new update schedule settings.
+
+ :param update_schedule:
+ :type update_schedule: UpdateSchedule
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_update_schedule_settings_serialize(
+ update_schedule=update_schedule,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_update_schedule_settings_without_preload_content(
+ self,
+ update_schedule: Optional[UpdateSchedule] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create update schedule settings
+
+ Create new update schedule settings.
+
+ :param update_schedule:
+ :type update_schedule: UpdateSchedule
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_update_schedule_settings_serialize(
+ update_schedule=update_schedule,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_update_schedule_settings_serialize(
+ self,
+ update_schedule,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if update_schedule is not None:
+ _body_params = update_schedule
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/update-schedule',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_update_schedule_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete update schedule settings
+
+ Delete the update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_update_schedule_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_update_schedule_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete update schedule settings
+
+ Delete the update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_update_schedule_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_update_schedule_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete update schedule settings
+
+ Delete the update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_update_schedule_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_update_schedule_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/update-schedule/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_update_schedule_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> UpdateSchedule:
+ """Get existing update schedule settings
+
+ Retrieve existing update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_update_schedule_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_update_schedule_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[UpdateSchedule]:
+ """Get existing update schedule settings
+
+ Retrieve existing update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_update_schedule_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_update_schedule_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing update schedule settings
+
+ Retrieve existing update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_update_schedule_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_update_schedule_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/update-schedule/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_update_schedule_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[UpdateSchedule]:
+ """List update schedule settings
+
+ Retrieve a list of update schedule settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_update_schedule_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[UpdateSchedule]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_update_schedule_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[UpdateSchedule]]:
+ """List update schedule settings
+
+ Retrieve a list of update schedule settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_update_schedule_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[UpdateSchedule]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_update_schedule_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List update schedule settings
+
+ Retrieve a list of update schedule settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_update_schedule_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[UpdateSchedule]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_update_schedule_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/update-schedule',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_update_schedule_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ update_schedule: Annotated[Optional[UpdateSchedule], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> UpdateSchedule:
+ """Update update schedule settings
+
+ Update the update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param update_schedule: OK
+ :type update_schedule: UpdateSchedule
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_update_schedule_settings_by_id_serialize(
+ id=id,
+ update_schedule=update_schedule,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_update_schedule_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ update_schedule: Annotated[Optional[UpdateSchedule], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[UpdateSchedule]:
+ """Update update schedule settings
+
+ Update the update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param update_schedule: OK
+ :type update_schedule: UpdateSchedule
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_update_schedule_settings_by_id_serialize(
+ id=id,
+ update_schedule=update_schedule,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_update_schedule_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ update_schedule: Annotated[Optional[UpdateSchedule], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update update schedule settings
+
+ Update the update schedule settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param update_schedule: OK
+ :type update_schedule: UpdateSchedule
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_update_schedule_settings_by_id_serialize(
+ id=id,
+ update_schedule=update_schedule,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UpdateSchedule",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_update_schedule_settings_by_id_serialize(
+ self,
+ id,
+ update_schedule,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if update_schedule is not None:
+ _body_params = update_schedule
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/update-schedule/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api/vpn_settings_api.py b/scm/device_settings/api/vpn_settings_api.py
new file mode 100644
index 00000000..2cadedc8
--- /dev/null
+++ b/scm/device_settings/api/vpn_settings_api.py
@@ -0,0 +1,1508 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr
+from typing import List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.vpn_settings import VpnSettings
+
+from scm.device_settings.api_client import ApiClient, RequestSerialized
+from scm.device_settings.api_response import ApiResponse
+from scm.device_settings.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class VPNSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_vpn_settings(
+ self,
+ vpn_settings: Optional[VpnSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VpnSettings:
+ """Create VPN settings
+
+ Create new VPN settings.
+
+ :param vpn_settings:
+ :type vpn_settings: VpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_vpn_settings_serialize(
+ vpn_settings=vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_vpn_settings_with_http_info(
+ self,
+ vpn_settings: Optional[VpnSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VpnSettings]:
+ """Create VPN settings
+
+ Create new VPN settings.
+
+ :param vpn_settings:
+ :type vpn_settings: VpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_vpn_settings_serialize(
+ vpn_settings=vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_vpn_settings_without_preload_content(
+ self,
+ vpn_settings: Optional[VpnSettings] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create VPN settings
+
+ Create new VPN settings.
+
+ :param vpn_settings:
+ :type vpn_settings: VpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_vpn_settings_serialize(
+ vpn_settings=vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_vpn_settings_serialize(
+ self,
+ vpn_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if vpn_settings is not None:
+ _body_params = vpn_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/vpn-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_vpn_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete VPN settings
+
+ Delete the VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_vpn_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_vpn_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete VPN settings
+
+ Delete the VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_vpn_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_vpn_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete VPN settings
+
+ Delete the VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_vpn_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_vpn_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/vpn-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_vpn_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VpnSettings:
+ """Get existing VPN settings
+
+ Retrieve existing VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_vpn_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_vpn_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VpnSettings]:
+ """Get existing VPN settings
+
+ Retrieve existing VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_vpn_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_vpn_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get existing VPN settings
+
+ Retrieve existing VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_vpn_settings_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_vpn_settings_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/vpn-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_vpn_settings(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> List[VpnSettings]:
+ """List VPN settings
+
+ Retrieve a list of VPN settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_vpn_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[VpnSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_vpn_settings_with_http_info(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[List[VpnSettings]]:
+ """List VPN settings
+
+ Retrieve a list of VPN settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_vpn_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[VpnSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_vpn_settings_without_preload_content(
+ self,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List VPN settings
+
+ Retrieve a list of VPN settings.
+
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_vpn_settings_serialize(
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "List[VpnSettings]",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_vpn_settings_serialize(
+ self,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/vpn-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_vpn_settings_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ vpn_settings: Annotated[Optional[VpnSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VpnSettings:
+ """Update VPN settings
+
+ Update the VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param vpn_settings: OK
+ :type vpn_settings: VpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_vpn_settings_by_id_serialize(
+ id=id,
+ vpn_settings=vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_vpn_settings_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ vpn_settings: Annotated[Optional[VpnSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VpnSettings]:
+ """Update VPN settings
+
+ Update the VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param vpn_settings: OK
+ :type vpn_settings: VpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_vpn_settings_by_id_serialize(
+ id=id,
+ vpn_settings=vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_vpn_settings_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ vpn_settings: Annotated[Optional[VpnSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update VPN settings
+
+ Update the VPN settings.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param vpn_settings: OK
+ :type vpn_settings: VpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_vpn_settings_by_id_serialize(
+ id=id,
+ vpn_settings=vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_vpn_settings_by_id_serialize(
+ self,
+ id,
+ vpn_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if vpn_settings is not None:
+ _body_params = vpn_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/vpn-settings/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/device_settings/api_client.py b/scm/device_settings/api_client.py
new file mode 100644
index 00000000..bd5cd84d
--- /dev/null
+++ b/scm/device_settings/api_client.py
@@ -0,0 +1,798 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import datetime
+from dateutil.parser import parse
+from enum import Enum
+import decimal
+import json
+import mimetypes
+import os
+import re
+import tempfile
+
+from urllib.parse import quote
+from typing import Tuple, Optional, List, Dict, Union
+from pydantic import SecretStr
+
+from scm.device_settings.configuration import Configuration
+from scm.device_settings.api_response import ApiResponse, T as ApiResponseT
+import scm.device_settings.models
+from scm.device_settings import rest
+from scm.device_settings.exceptions import (
+ ApiValueError,
+ ApiException,
+ BadRequestException,
+ UnauthorizedException,
+ ForbiddenException,
+ NotFoundException,
+ ServiceException
+)
+
+RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]
+
+class ApiClient:
+ """Generic API client for OpenAPI client library builds.
+
+ OpenAPI generic API client. This client handles the client-
+ server communication, and is invariant across implementations. Specifics of
+ the methods and models for each application are generated from the OpenAPI
+ templates.
+
+ :param configuration: .Configuration object for this client
+ :param header_name: a header to pass when making calls to the API.
+ :param header_value: a header value to pass when making calls to
+ the API.
+ :param cookie: a cookie to include in the header when making calls
+ to the API
+ """
+
+ PRIMITIVE_TYPES = (float, bool, bytes, str, int)
+ NATIVE_TYPES_MAPPING = {
+ 'int': int,
+ 'long': int, # TODO remove as only py3 is supported?
+ 'float': float,
+ 'str': str,
+ 'bool': bool,
+ 'date': datetime.date,
+ 'datetime': datetime.datetime,
+ 'decimal': decimal.Decimal,
+ 'object': object,
+ }
+ _pool = None
+
+ def __init__(
+ self,
+ configuration=None,
+ header_name=None,
+ header_value=None,
+ cookie=None
+ ) -> None:
+ # use default configuration if none is provided
+ if configuration is None:
+ configuration = Configuration.get_default()
+ self.configuration = configuration
+
+ self.rest_client = rest.RESTClientObject(configuration)
+ self.default_headers = {}
+ if header_name is not None:
+ self.default_headers[header_name] = header_value
+ self.cookie = cookie
+ # Set default User-Agent.
+ self.user_agent = 'OpenAPI-Generator/1.0.0/python'
+ self.client_side_validation = configuration.client_side_validation
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ pass
+
+ @property
+ def user_agent(self):
+ """User agent for this API client"""
+ return self.default_headers['User-Agent']
+
+ @user_agent.setter
+ def user_agent(self, value):
+ self.default_headers['User-Agent'] = value
+
+ def set_default_header(self, header_name, header_value):
+ self.default_headers[header_name] = header_value
+
+
+ _default = None
+
+ @classmethod
+ def get_default(cls):
+ """Return new instance of ApiClient.
+
+ This method returns newly created, based on default constructor,
+ object of ApiClient class or returns a copy of default
+ ApiClient.
+
+ :return: The ApiClient object.
+ """
+ if cls._default is None:
+ cls._default = ApiClient()
+ return cls._default
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of ApiClient.
+
+ It stores default ApiClient.
+
+ :param default: object of ApiClient.
+ """
+ cls._default = default
+
+ def param_serialize(
+ self,
+ method,
+ resource_path,
+ path_params=None,
+ query_params=None,
+ header_params=None,
+ body=None,
+ post_params=None,
+ files=None, auth_settings=None,
+ collection_formats=None,
+ _host=None,
+ _request_auth=None
+ ) -> RequestSerialized:
+
+ """Builds the HTTP request params needed by the request.
+ :param method: Method to call.
+ :param resource_path: Path to method endpoint.
+ :param path_params: Path parameters in the url.
+ :param query_params: Query parameters in the url.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param auth_settings list: Auth Settings names for the request.
+ :param files dict: key -> filename, value -> filepath,
+ for `multipart/form-data`.
+ :param collection_formats: dict of collection formats for path, query,
+ header, and post parameters.
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the authentication
+ in the spec for a single request.
+ :return: tuple of form (path, http_method, query_params, header_params,
+ body, post_params, files)
+ """
+
+ config = self.configuration
+
+ # header parameters
+ header_params = header_params or {}
+ header_params.update(self.default_headers)
+ if self.cookie:
+ header_params['Cookie'] = self.cookie
+ if header_params:
+ header_params = self.sanitize_for_serialization(header_params)
+ header_params = dict(
+ self.parameters_to_tuples(header_params,collection_formats)
+ )
+
+ # path parameters
+ if path_params:
+ path_params = self.sanitize_for_serialization(path_params)
+ path_params = self.parameters_to_tuples(
+ path_params,
+ collection_formats
+ )
+ for k, v in path_params:
+ # specified safe chars, encode everything
+ resource_path = resource_path.replace(
+ '{%s}' % k,
+ quote(str(v), safe=config.safe_chars_for_path_param)
+ )
+
+ # post parameters
+ if post_params or files:
+ post_params = post_params if post_params else []
+ post_params = self.sanitize_for_serialization(post_params)
+ post_params = self.parameters_to_tuples(
+ post_params,
+ collection_formats
+ )
+ if files:
+ post_params.extend(self.files_parameters(files))
+
+ # auth setting
+ self.update_params_for_auth(
+ header_params,
+ query_params,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=_request_auth
+ )
+
+ # body
+ if body:
+ body = self.sanitize_for_serialization(body)
+
+ # request url
+ if _host is None or self.configuration.ignore_operation_servers:
+ url = self.configuration.host + resource_path
+ else:
+ # use server/host defined in path or operation instead
+ url = _host + resource_path
+
+ # query parameters
+ if query_params:
+ query_params = self.sanitize_for_serialization(query_params)
+ url_query = self.parameters_to_url_query(
+ query_params,
+ collection_formats
+ )
+ url += "?" + url_query
+
+ return method, url, header_params, body, post_params
+
+
+ def call_api(
+ self,
+ method,
+ url,
+ header_params=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ) -> rest.RESTResponse:
+ """Makes the HTTP request (synchronous)
+ :param method: Method to call.
+ :param url: Path to method endpoint.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param _request_timeout: timeout setting for this request.
+ :return: RESTResponse
+ """
+
+ try:
+ # perform request and return response
+ response_data = self.rest_client.request(
+ method, url,
+ headers=header_params,
+ body=body, post_params=post_params,
+ _request_timeout=_request_timeout
+ )
+
+ except ApiException as e:
+ raise e
+
+ return response_data
+
+ def response_deserialize(
+ self,
+ response_data: rest.RESTResponse,
+ response_types_map: Optional[Dict[str, ApiResponseT]]=None
+ ) -> ApiResponse[ApiResponseT]:
+ """Deserializes response into an object.
+ :param response_data: RESTResponse object to be deserialized.
+ :param response_types_map: dict of response types.
+ :return: ApiResponse
+ """
+
+ msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
+ assert response_data.data is not None, msg
+
+ response_type = response_types_map.get(str(response_data.status), None)
+ if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
+ # if not found, look for '1XX', '2XX', etc.
+ response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
+
+ # deserialize response data
+ response_text = None
+ return_data = None
+ try:
+ if response_type == "bytearray":
+ return_data = response_data.data
+ elif response_type == "file":
+ return_data = self.__deserialize_file(response_data)
+ elif response_type is not None:
+ match = None
+ content_type = response_data.getheader('content-type')
+ if content_type is not None:
+ match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
+ encoding = match.group(1) if match else "utf-8"
+ response_text = response_data.data.decode(encoding)
+ return_data = self.deserialize(response_text, response_type, content_type)
+ finally:
+ if not 200 <= response_data.status <= 299:
+ raise ApiException.from_response(
+ http_resp=response_data,
+ body=response_text,
+ data=return_data,
+ )
+
+ return ApiResponse(
+ status_code = response_data.status,
+ data = return_data,
+ headers = response_data.getheaders(),
+ raw_data = response_data.data
+ )
+
+ def sanitize_for_serialization(self, obj):
+ """Builds a JSON POST object.
+
+ If obj is None, return None.
+ If obj is SecretStr, return obj.get_secret_value()
+ If obj is str, int, long, float, bool, return directly.
+ If obj is datetime.datetime, datetime.date
+ convert to string in iso8601 format.
+ If obj is decimal.Decimal return string representation.
+ If obj is list, sanitize each element in the list.
+ If obj is dict, return the dict.
+ If obj is OpenAPI model, return the properties dict.
+
+ :param obj: The data to serialize.
+ :return: The serialized form of data.
+ """
+ if obj is None:
+ return None
+ elif isinstance(obj, Enum):
+ return obj.value
+ elif isinstance(obj, SecretStr):
+ return obj.get_secret_value()
+ elif isinstance(obj, self.PRIMITIVE_TYPES):
+ return obj
+ elif isinstance(obj, list):
+ return [
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ ]
+ elif isinstance(obj, tuple):
+ return tuple(
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ )
+ elif isinstance(obj, (datetime.datetime, datetime.date)):
+ return obj.isoformat()
+ elif isinstance(obj, decimal.Decimal):
+ return str(obj)
+
+ elif isinstance(obj, dict):
+ obj_dict = obj
+ else:
+ # Convert model obj to dict except
+ # attributes `openapi_types`, `attribute_map`
+ # and attributes which value is not None.
+ # Convert attribute name to json key in
+ # model definition for request.
+ if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
+ obj_dict = obj.to_dict()
+ else:
+ obj_dict = obj.__dict__
+
+ return {
+ key: self.sanitize_for_serialization(val)
+ for key, val in obj_dict.items()
+ }
+
+ def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]):
+ """Deserializes response into an object.
+
+ :param response: RESTResponse object to be deserialized.
+ :param response_type: class literal for
+ deserialized object, or string of class name.
+ :param content_type: content type of response.
+
+ :return: deserialized object.
+ """
+
+ # fetch data from response object
+ if content_type is None:
+ try:
+ data = json.loads(response_text)
+ except ValueError:
+ data = response_text
+ elif re.match(r'^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)', content_type, re.IGNORECASE):
+ if response_text == "":
+ data = ""
+ else:
+ data = json.loads(response_text)
+ elif re.match(r'^text\/[a-z.+-]+\s*(;|$)', content_type, re.IGNORECASE):
+ data = response_text
+ else:
+ raise ApiException(
+ status=0,
+ reason="Unsupported content type: {0}".format(content_type)
+ )
+
+ return self.__deserialize(data, response_type)
+
+ def __deserialize(self, data, klass):
+ """Deserializes dict, list, str into an object.
+
+ :param data: dict, list or str.
+ :param klass: class literal, or string of class name.
+
+ :return: object.
+ """
+ if data is None:
+ return None
+
+ if isinstance(klass, str):
+ if klass.startswith('List['):
+ m = re.match(r'List\[(.*)]', klass)
+ assert m is not None, "Malformed List type definition"
+ sub_kls = m.group(1)
+ return [self.__deserialize(sub_data, sub_kls)
+ for sub_data in data]
+
+ if klass.startswith('Dict['):
+ m = re.match(r'Dict\[([^,]*), (.*)]', klass)
+ assert m is not None, "Malformed Dict type definition"
+ sub_kls = m.group(2)
+ return {k: self.__deserialize(v, sub_kls)
+ for k, v in data.items()}
+
+ # convert str to class
+ if klass in self.NATIVE_TYPES_MAPPING:
+ klass = self.NATIVE_TYPES_MAPPING[klass]
+ else:
+ klass = getattr(scm.device_settings.models, klass)
+
+ if klass in self.PRIMITIVE_TYPES:
+ return self.__deserialize_primitive(data, klass)
+ elif klass == object:
+ return self.__deserialize_object(data)
+ elif klass == datetime.date:
+ return self.__deserialize_date(data)
+ elif klass == datetime.datetime:
+ return self.__deserialize_datetime(data)
+ elif klass == decimal.Decimal:
+ return decimal.Decimal(data)
+ elif issubclass(klass, Enum):
+ return self.__deserialize_enum(data, klass)
+ else:
+ return self.__deserialize_model(data, klass)
+
+ def parameters_to_tuples(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: Parameters as list of tuples, collections formatted
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, value) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(str(value) for value in v)))
+ else:
+ new_params.append((k, v))
+ return new_params
+
+ def parameters_to_url_query(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: URL query string (e.g. a=Hello%20World&b=123)
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if isinstance(v, bool):
+ v = str(v).lower()
+ if isinstance(v, (int, float)):
+ v = str(v)
+ if isinstance(v, dict):
+ v = json.dumps(v)
+
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, str(value)) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(quote(str(value)) for value in v))
+ )
+ else:
+ new_params.append((k, quote(str(v))))
+
+ return "&".join(["=".join(map(str, item)) for item in new_params])
+
+ def files_parameters(
+ self,
+ files: Dict[str, Union[str, bytes, List[str], List[bytes], Tuple[str, bytes]]],
+ ):
+ """Builds form parameters.
+
+ :param files: File parameters.
+ :return: Form parameters with files.
+ """
+ params = []
+ for k, v in files.items():
+ if isinstance(v, str):
+ with open(v, 'rb') as f:
+ filename = os.path.basename(f.name)
+ filedata = f.read()
+ elif isinstance(v, bytes):
+ filename = k
+ filedata = v
+ elif isinstance(v, tuple):
+ filename, filedata = v
+ elif isinstance(v, list):
+ for file_param in v:
+ params.extend(self.files_parameters({k: file_param}))
+ continue
+ else:
+ raise ValueError("Unsupported file value")
+ mimetype = (
+ mimetypes.guess_type(filename)[0]
+ or 'application/octet-stream'
+ )
+ params.append(
+ tuple([k, tuple([filename, filedata, mimetype])])
+ )
+ return params
+
+ def select_header_accept(self, accepts: List[str]) -> Optional[str]:
+ """Returns `Accept` based on an array of accepts provided.
+
+ :param accepts: List of headers.
+ :return: Accept (e.g. application/json).
+ """
+ if not accepts:
+ return None
+
+ for accept in accepts:
+ if re.search('json', accept, re.IGNORECASE):
+ return accept
+
+ return accepts[0]
+
+ def select_header_content_type(self, content_types):
+ """Returns `Content-Type` based on an array of content_types provided.
+
+ :param content_types: List of content-types.
+ :return: Content-Type (e.g. application/json).
+ """
+ if not content_types:
+ return None
+
+ for content_type in content_types:
+ if re.search('json', content_type, re.IGNORECASE):
+ return content_type
+
+ return content_types[0]
+
+ def update_params_for_auth(
+ self,
+ headers,
+ queries,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=None
+ ) -> None:
+ """Updates header and query params based on authentication setting.
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :param auth_settings: Authentication setting identifiers list.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param request_auth: if set, the provided settings will
+ override the token in the configuration.
+ """
+ if not auth_settings:
+ return
+
+ if request_auth:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ request_auth
+ )
+ else:
+ for auth in auth_settings:
+ auth_setting = self.configuration.auth_settings().get(auth)
+ if auth_setting:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ )
+
+ def _apply_auth_params(
+ self,
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ ) -> None:
+ """Updates the request parameters based on a single auth_setting
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param auth_setting: auth settings for the endpoint
+ """
+ if auth_setting['in'] == 'cookie':
+ headers['Cookie'] = auth_setting['value']
+ elif auth_setting['in'] == 'header':
+ if auth_setting['type'] != 'http-signature':
+ headers[auth_setting['key']] = auth_setting['value']
+ elif auth_setting['in'] == 'query':
+ queries.append((auth_setting['key'], auth_setting['value']))
+ else:
+ raise ApiValueError(
+ 'Authentication token must be in `query` or `header`'
+ )
+
+ def __deserialize_file(self, response):
+ """Deserializes body to file
+
+ Saves response body into a file in a temporary folder,
+ using the filename from the `Content-Disposition` header if provided.
+
+ handle file downloading
+ save response body into a tmp file and return the instance
+
+ :param response: RESTResponse.
+ :return: file path.
+ """
+ fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
+ os.close(fd)
+ os.remove(path)
+
+ content_disposition = response.getheader("Content-Disposition")
+ if content_disposition:
+ m = re.search(
+ r'filename=[\'"]?([^\'"\s]+)[\'"]?',
+ content_disposition
+ )
+ assert m is not None, "Unexpected 'content-disposition' header value"
+ filename = m.group(1)
+ path = os.path.join(os.path.dirname(path), filename)
+
+ with open(path, "wb") as f:
+ f.write(response.data)
+
+ return path
+
+ def __deserialize_primitive(self, data, klass):
+ """Deserializes string to primitive type.
+
+ :param data: str.
+ :param klass: class literal.
+
+ :return: int, long, float, str, bool.
+ """
+ try:
+ return klass(data)
+ except UnicodeEncodeError:
+ return str(data)
+ except TypeError:
+ return data
+
+ def __deserialize_object(self, value):
+ """Return an original value.
+
+ :return: object.
+ """
+ return value
+
+ def __deserialize_date(self, string):
+ """Deserializes string to date.
+
+ :param string: str.
+ :return: date.
+ """
+ try:
+ return parse(string).date()
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason="Failed to parse `{0}` as date object".format(string)
+ )
+
+ def __deserialize_datetime(self, string):
+ """Deserializes string to datetime.
+
+ The string should be in iso8601 datetime format.
+
+ :param string: str.
+ :return: datetime.
+ """
+ try:
+ return parse(string)
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as datetime object"
+ .format(string)
+ )
+ )
+
+ def __deserialize_enum(self, data, klass):
+ """Deserializes primitive type to enum.
+
+ :param data: primitive type.
+ :param klass: class literal.
+ :return: enum value.
+ """
+ try:
+ return klass(data)
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as `{1}`"
+ .format(data, klass)
+ )
+ )
+
+ def __deserialize_model(self, data, klass):
+ """Deserializes list or dict to model.
+
+ :param data: dict, list.
+ :param klass: class literal.
+ :return: model object.
+ """
+
+ return klass.from_dict(data)
diff --git a/scm/device_settings/api_response.py b/scm/device_settings/api_response.py
new file mode 100644
index 00000000..9bc7c11f
--- /dev/null
+++ b/scm/device_settings/api_response.py
@@ -0,0 +1,21 @@
+"""API response object."""
+
+from __future__ import annotations
+from typing import Optional, Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+ """
+ API response object
+ """
+
+ status_code: StrictInt = Field(description="HTTP status code")
+ headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
+ data: T = Field(description="Deserialized data given the data type")
+ raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
+
+ model_config = {
+ "arbitrary_types_allowed": True
+ }
diff --git a/scm/device_settings/configuration.py b/scm/device_settings/configuration.py
new file mode 100644
index 00000000..e37d8196
--- /dev/null
+++ b/scm/device_settings/configuration.py
@@ -0,0 +1,467 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import copy
+import logging
+from logging import FileHandler
+import multiprocessing
+import sys
+from typing import Optional
+import urllib3
+
+import http.client as httplib
+
+JSON_SCHEMA_VALIDATION_KEYWORDS = {
+ 'multipleOf', 'maximum', 'exclusiveMaximum',
+ 'minimum', 'exclusiveMinimum', 'maxLength',
+ 'minLength', 'pattern', 'maxItems', 'minItems'
+}
+
+class Configuration:
+ """This class contains various settings of the API client.
+
+ :param host: Base url.
+ :param ignore_operation_servers
+ Boolean to ignore operation servers for the API client.
+ Config will use `host` as the base url regardless of the operation servers.
+ :param api_key: Dict to store API key(s).
+ Each entry in the dict specifies an API key.
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is the API key secret.
+ :param api_key_prefix: Dict to store API prefix (e.g. Bearer).
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is an API key prefix when generating the auth data.
+ :param username: Username for HTTP basic authentication.
+ :param password: Password for HTTP basic authentication.
+ :param access_token: Access token.
+ :param server_index: Index to servers configuration.
+ :param server_variables: Mapping with string values to replace variables in
+ templated server configuration. The validation of enums is performed for
+ variables with defined enum values before.
+ :param server_operation_index: Mapping from operation ID to an index to server
+ configuration.
+ :param server_operation_variables: Mapping from operation ID to a mapping with
+ string values to replace variables in templated server configuration.
+ The validation of enums is performed for variables with defined enum
+ values before.
+ :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
+ in PEM format.
+ :param retries: Number of retries for API requests.
+
+ :Example:
+ """
+
+ _default = None
+
+ def __init__(self, host=None,
+ api_key=None, api_key_prefix=None,
+ username=None, password=None,
+ access_token=None,
+ server_index=None, server_variables=None,
+ server_operation_index=None, server_operation_variables=None,
+ ignore_operation_servers=False,
+ ssl_ca_cert=None,
+ retries=None,
+ *,
+ debug: Optional[bool] = None
+ ) -> None:
+ """Constructor
+ """
+ self._base_path = "https://api.strata.paloaltonetworks.com/config/device/v1" if host is None else host
+ """Default Base url
+ """
+ self.server_index = 0 if server_index is None and host is None else server_index
+ self.server_operation_index = server_operation_index or {}
+ """Default server index
+ """
+ self.server_variables = server_variables or {}
+ self.server_operation_variables = server_operation_variables or {}
+ """Default server variables
+ """
+ self.ignore_operation_servers = ignore_operation_servers
+ """Ignore operation servers
+ """
+ self.temp_folder_path = None
+ """Temp file folder for downloading files
+ """
+ # Authentication Settings
+ self.api_key = {}
+ if api_key:
+ self.api_key = api_key
+ """dict to store API key(s)
+ """
+ self.api_key_prefix = {}
+ if api_key_prefix:
+ self.api_key_prefix = api_key_prefix
+ """dict to store API prefix (e.g. Bearer)
+ """
+ self.refresh_api_key_hook = None
+ """function hook to refresh API key if expired
+ """
+ self.username = username
+ """Username for HTTP basic authentication
+ """
+ self.password = password
+ """Password for HTTP basic authentication
+ """
+ self.access_token = access_token
+ """Access token
+ """
+ self.logger = {}
+ """Logging Settings
+ """
+ self.logger["package_logger"] = logging.getLogger("scm.device_settings")
+ self.logger["urllib3_logger"] = logging.getLogger("urllib3")
+ self.logger_format = '%(asctime)s %(levelname)s %(message)s'
+ """Log format
+ """
+ self.logger_stream_handler = None
+ """Log stream handler
+ """
+ self.logger_file_handler: Optional[FileHandler] = None
+ """Log file handler
+ """
+ self.logger_file = None
+ """Debug file location
+ """
+ if debug is not None:
+ self.debug = debug
+ else:
+ self.__debug = False
+ """Debug switch
+ """
+
+ self.verify_ssl = True
+ """SSL/TLS verification
+ Set this to false to skip verifying SSL certificate when calling API
+ from https server.
+ """
+ self.ssl_ca_cert = ssl_ca_cert
+ """Set this to customize the certificate file to verify the peer.
+ """
+ self.cert_file = None
+ """client certificate file
+ """
+ self.key_file = None
+ """client key file
+ """
+ self.assert_hostname = None
+ """Set this to True/False to enable/disable SSL hostname verification.
+ """
+ self.tls_server_name = None
+ """SSL/TLS Server Name Indication (SNI)
+ Set this to the SNI value expected by the server.
+ """
+
+ self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
+ """urllib3 connection pool's maximum number of connections saved
+ per pool. urllib3 uses 1 connection as default value, but this is
+ not the best value when you are making a lot of possibly parallel
+ requests to the same host, which is often the case here.
+ cpu_count * 5 is used as default value to increase performance.
+ """
+
+ self.proxy: Optional[str] = None
+ """Proxy URL
+ """
+ self.proxy_headers = None
+ """Proxy headers
+ """
+ self.safe_chars_for_path_param = ''
+ """Safe chars for path_param
+ """
+ self.retries = retries
+ """Adding retries to override urllib3 default value 3
+ """
+ # Enable client side validation
+ self.client_side_validation = True
+
+ self.socket_options = None
+ """Options to pass down to the underlying urllib3 socket
+ """
+
+ self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z"
+ """datetime format
+ """
+
+ self.date_format = "%Y-%m-%d"
+ """date format
+ """
+
+ def __deepcopy__(self, memo):
+ cls = self.__class__
+ result = cls.__new__(cls)
+ memo[id(self)] = result
+ for k, v in self.__dict__.items():
+ if k not in ('logger', 'logger_file_handler'):
+ setattr(result, k, copy.deepcopy(v, memo))
+ # shallow copy of loggers
+ result.logger = copy.copy(self.logger)
+ # use setters to configure loggers
+ result.logger_file = self.logger_file
+ result.debug = self.debug
+ return result
+
+ def __setattr__(self, name, value):
+ object.__setattr__(self, name, value)
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of configuration.
+
+ It stores default configuration, which can be
+ returned by get_default_copy method.
+
+ :param default: object of Configuration
+ """
+ cls._default = default
+
+ @classmethod
+ def get_default_copy(cls):
+ """Deprecated. Please use `get_default` instead.
+
+ Deprecated. Please use `get_default` instead.
+
+ :return: The configuration object.
+ """
+ return cls.get_default()
+
+ @classmethod
+ def get_default(cls):
+ """Return the default configuration.
+
+ This method returns newly created, based on default constructor,
+ object of Configuration class or returns a copy of default
+ configuration.
+
+ :return: The configuration object.
+ """
+ if cls._default is None:
+ cls._default = Configuration()
+ return cls._default
+
+ @property
+ def logger_file(self):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ return self.__logger_file
+
+ @logger_file.setter
+ def logger_file(self, value):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ self.__logger_file = value
+ if self.__logger_file:
+ # If set logging file,
+ # then add file handler and remove stream handler.
+ self.logger_file_handler = logging.FileHandler(self.__logger_file)
+ self.logger_file_handler.setFormatter(self.logger_formatter)
+ for _, logger in self.logger.items():
+ logger.addHandler(self.logger_file_handler)
+
+ @property
+ def debug(self):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ return self.__debug
+
+ @debug.setter
+ def debug(self, value):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ self.__debug = value
+ if self.__debug:
+ # if debug status is True, turn on debug logging
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.DEBUG)
+ # turn on httplib debug
+ httplib.HTTPConnection.debuglevel = 1
+ else:
+ # if debug status is False, turn off debug logging,
+ # setting log level to default `logging.WARNING`
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.WARNING)
+ # turn off httplib debug
+ httplib.HTTPConnection.debuglevel = 0
+
+ @property
+ def logger_format(self):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ return self.__logger_format
+
+ @logger_format.setter
+ def logger_format(self, value):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ self.__logger_format = value
+ self.logger_formatter = logging.Formatter(self.__logger_format)
+
+ def get_api_key_with_prefix(self, identifier, alias=None):
+ """Gets API key (with prefix if set).
+
+ :param identifier: The identifier of apiKey.
+ :param alias: The alternative identifier of apiKey.
+ :return: The token for api key authentication.
+ """
+ if self.refresh_api_key_hook is not None:
+ self.refresh_api_key_hook(self)
+ key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
+ if key:
+ prefix = self.api_key_prefix.get(identifier)
+ if prefix:
+ return "%s %s" % (prefix, key)
+ else:
+ return key
+
+ def get_basic_auth_token(self):
+ """Gets HTTP basic authentication header (string).
+
+ :return: The token for basic HTTP authentication.
+ """
+ username = ""
+ if self.username is not None:
+ username = self.username
+ password = ""
+ if self.password is not None:
+ password = self.password
+ return urllib3.util.make_headers(
+ basic_auth=username + ':' + password
+ ).get('authorization')
+
+ def auth_settings(self):
+ """Gets Auth Settings dict for api client.
+
+ :return: The Auth Settings information dict.
+ """
+ auth = {}
+ if self.access_token is not None:
+ auth['scmOAuth'] = {
+ 'type': 'oauth2',
+ 'in': 'header',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ if self.access_token is not None:
+ auth['scmToken'] = {
+ 'type': 'bearer',
+ 'in': 'header',
+ 'format': 'JWT',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ return auth
+
+ def to_debug_report(self):
+ """Gets the essential information for debugging.
+
+ :return: The report for debugging.
+ """
+ return "Python SDK Debug Report:\n"\
+ "OS: {env}\n"\
+ "Python Version: {pyversion}\n"\
+ "Version of the API: 2.0.0\n"\
+ "SDK Package Version: 1.0.0".\
+ format(env=sys.platform, pyversion=sys.version)
+
+ def get_host_settings(self):
+ """Gets an array of host settings
+
+ :return: An array of host settings
+ """
+ return [
+ {
+ 'url': "https://api.strata.paloaltonetworks.com/config/device/v1",
+ 'description': "Production",
+ }
+ ]
+
+ def get_host_from_settings(self, index, variables=None, servers=None):
+ """Gets host URL based on the index and variables
+ :param index: array index of the host settings
+ :param variables: hash of variable and the corresponding value
+ :param servers: an array of host settings or None
+ :return: URL based on host settings
+ """
+ if index is None:
+ return self._base_path
+
+ variables = {} if variables is None else variables
+ servers = self.get_host_settings() if servers is None else servers
+
+ try:
+ server = servers[index]
+ except IndexError:
+ raise ValueError(
+ "Invalid index {0} when selecting the host settings. "
+ "Must be less than {1}".format(index, len(servers)))
+
+ url = server['url']
+
+ # go through variables and replace placeholders
+ for variable_name, variable in server.get('variables', {}).items():
+ used_value = variables.get(
+ variable_name, variable['default_value'])
+
+ if 'enum_values' in variable \
+ and used_value not in variable['enum_values']:
+ raise ValueError(
+ "The variable `{0}` in the host URL has invalid value "
+ "{1}. Must be {2}.".format(
+ variable_name, variables[variable_name],
+ variable['enum_values']))
+
+ url = url.replace("{" + variable_name + "}", used_value)
+
+ return url
+
+ @property
+ def host(self):
+ """Return generated host."""
+ return self.get_host_from_settings(self.server_index, variables=self.server_variables)
+
+ @host.setter
+ def host(self, value):
+ """Fix base path."""
+ self._base_path = value
+ self.server_index = None
diff --git a/scm/device_settings/docs/AuthenticationSettings.md b/scm/device_settings/docs/AuthenticationSettings.md
new file mode 100644
index 00000000..2f6a64b4
--- /dev/null
+++ b/scm/device_settings/docs/AuthenticationSettings.md
@@ -0,0 +1,33 @@
+# AuthenticationSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authentication** | [**AuthenticationSettingsAuthentication**](AuthenticationSettingsAuthentication.md) | | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [readonly]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationSettings from a JSON string
+authentication_settings_instance = AuthenticationSettings.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationSettings.to_json())
+
+# convert the object into a dict
+authentication_settings_dict = authentication_settings_instance.to_dict()
+# create an instance of AuthenticationSettings from a dict
+authentication_settings_from_dict = AuthenticationSettings.from_dict(authentication_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/AuthenticationSettingsApi.md b/scm/device_settings/docs/AuthenticationSettingsApi.md
new file mode 100644
index 00000000..3ba1f345
--- /dev/null
+++ b/scm/device_settings/docs/AuthenticationSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.AuthenticationSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_authentication_settings**](AuthenticationSettingsApi.md#create_authentication_settings) | **POST** /authentication-settings | Create authentication settings
+[**delete_authentication_settings_by_id**](AuthenticationSettingsApi.md#delete_authentication_settings_by_id) | **DELETE** /authentication-settings/{id} | Delete authentication settings
+[**get_authentication_settings_by_id**](AuthenticationSettingsApi.md#get_authentication_settings_by_id) | **GET** /authentication-settings/{id} | Get existing authentication settings
+[**list_authentication_settings**](AuthenticationSettingsApi.md#list_authentication_settings) | **GET** /authentication-settings | List authentication settings
+[**update_authentication_settings_by_id**](AuthenticationSettingsApi.md#update_authentication_settings_by_id) | **PUT** /authentication-settings/{id} | Update authentication settings
+
+
+# **create_authentication_settings**
+> AuthenticationSettings create_authentication_settings(authentication_settings=authentication_settings)
+
+Create authentication settings
+
+Create new device authentication settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.AuthenticationSettingsApi(api_client)
+ authentication_settings = scm.device_settings.AuthenticationSettings() # AuthenticationSettings | (optional)
+
+ try:
+ # Create authentication settings
+ api_response = api_instance.create_authentication_settings(authentication_settings=authentication_settings)
+ print("The response of AuthenticationSettingsApi->create_authentication_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSettingsApi->create_authentication_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **authentication_settings** | [**AuthenticationSettings**](AuthenticationSettings.md)| | [optional]
+
+### Return type
+
+[**AuthenticationSettings**](AuthenticationSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_authentication_settings_by_id**
+> delete_authentication_settings_by_id(id)
+
+Delete authentication settings
+
+Delete the device authentication settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.AuthenticationSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete authentication settings
+ api_instance.delete_authentication_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling AuthenticationSettingsApi->delete_authentication_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_authentication_settings_by_id**
+> AuthenticationSettings get_authentication_settings_by_id(id)
+
+Get existing authentication settings
+
+Retrieve existing device authentication settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.AuthenticationSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing authentication settings
+ api_response = api_instance.get_authentication_settings_by_id(id)
+ print("The response of AuthenticationSettingsApi->get_authentication_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSettingsApi->get_authentication_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**AuthenticationSettings**](AuthenticationSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_authentication_settings**
+> List[AuthenticationSettings] list_authentication_settings(folder=folder, snippet=snippet, device=device)
+
+List authentication settings
+
+Retrieve a list of device authentication settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.AuthenticationSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List authentication settings
+ api_response = api_instance.list_authentication_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of AuthenticationSettingsApi->list_authentication_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSettingsApi->list_authentication_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[AuthenticationSettings]**](AuthenticationSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_authentication_settings_by_id**
+> AuthenticationSettings update_authentication_settings_by_id(id, authentication_settings=authentication_settings)
+
+Update authentication settings
+
+Update the device authentication settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.AuthenticationSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ authentication_settings = scm.device_settings.AuthenticationSettings() # AuthenticationSettings | (optional)
+
+ try:
+ # Update authentication settings
+ api_response = api_instance.update_authentication_settings_by_id(id, authentication_settings=authentication_settings)
+ print("The response of AuthenticationSettingsApi->update_authentication_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSettingsApi->update_authentication_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **authentication_settings** | [**AuthenticationSettings**](AuthenticationSettings.md)| | [optional]
+
+### Return type
+
+[**AuthenticationSettings**](AuthenticationSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/AuthenticationSettingsAuthentication.md b/scm/device_settings/docs/AuthenticationSettingsAuthentication.md
new file mode 100644
index 00000000..1a7858f6
--- /dev/null
+++ b/scm/device_settings/docs/AuthenticationSettingsAuthentication.md
@@ -0,0 +1,31 @@
+# AuthenticationSettingsAuthentication
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**accounting_server_profile** | **str** | Accounting server profile | [optional]
+**authentication_profile** | **str** | Authentication profile | [optional]
+**certificate_profile** | **str** | Certificate profile | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.authentication_settings_authentication import AuthenticationSettingsAuthentication
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationSettingsAuthentication from a JSON string
+authentication_settings_authentication_instance = AuthenticationSettingsAuthentication.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationSettingsAuthentication.to_json())
+
+# convert the object into a dict
+authentication_settings_authentication_dict = authentication_settings_authentication_instance.to_dict()
+# create an instance of AuthenticationSettingsAuthentication from a dict
+authentication_settings_authentication_from_dict = AuthenticationSettingsAuthentication.from_dict(authentication_settings_authentication_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ContentIDSettingsApi.md b/scm/device_settings/docs/ContentIDSettingsApi.md
new file mode 100644
index 00000000..1e18ea43
--- /dev/null
+++ b/scm/device_settings/docs/ContentIDSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.ContentIDSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_content_id_settings**](ContentIDSettingsApi.md#create_content_id_settings) | **POST** /content-id-settings | Create Content-ID settings
+[**delete_content_id_settings_by_id**](ContentIDSettingsApi.md#delete_content_id_settings_by_id) | **DELETE** /content-id-settings/{id} | Delete Content-ID settings
+[**get_content_id_settings_by_id**](ContentIDSettingsApi.md#get_content_id_settings_by_id) | **GET** /content-id-settings/{id} | Get existing Content-ID settings
+[**list_content_id_settings**](ContentIDSettingsApi.md#list_content_id_settings) | **GET** /content-id-settings | List Content-ID settings
+[**update_content_id_settings_by_id**](ContentIDSettingsApi.md#update_content_id_settings_by_id) | **PUT** /content-id-settings/{id} | Update Content-ID settings
+
+
+# **create_content_id_settings**
+> ContentIdSettings create_content_id_settings(content_id_settings=content_id_settings)
+
+Create Content-ID settings
+
+Create new Content-ID settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ContentIDSettingsApi(api_client)
+ content_id_settings = scm.device_settings.ContentIdSettings() # ContentIdSettings | (optional)
+
+ try:
+ # Create Content-ID settings
+ api_response = api_instance.create_content_id_settings(content_id_settings=content_id_settings)
+ print("The response of ContentIDSettingsApi->create_content_id_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ContentIDSettingsApi->create_content_id_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **content_id_settings** | [**ContentIdSettings**](ContentIdSettings.md)| | [optional]
+
+### Return type
+
+[**ContentIdSettings**](ContentIdSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_content_id_settings_by_id**
+> delete_content_id_settings_by_id(id)
+
+Delete Content-ID settings
+
+Delete the Content-ID settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ContentIDSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete Content-ID settings
+ api_instance.delete_content_id_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling ContentIDSettingsApi->delete_content_id_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_content_id_settings_by_id**
+> ContentIdSettings get_content_id_settings_by_id(id)
+
+Get existing Content-ID settings
+
+Retrieve existing Content-ID settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ContentIDSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing Content-ID settings
+ api_response = api_instance.get_content_id_settings_by_id(id)
+ print("The response of ContentIDSettingsApi->get_content_id_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ContentIDSettingsApi->get_content_id_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**ContentIdSettings**](ContentIdSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_content_id_settings**
+> List[ContentIdSettings] list_content_id_settings(folder=folder, snippet=snippet, device=device)
+
+List Content-ID settings
+
+Retrieve a list of Content-ID settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ContentIDSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List Content-ID settings
+ api_response = api_instance.list_content_id_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of ContentIDSettingsApi->list_content_id_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ContentIDSettingsApi->list_content_id_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[ContentIdSettings]**](ContentIdSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_content_id_settings_by_id**
+> ContentIdSettings update_content_id_settings_by_id(id, content_id_settings=content_id_settings)
+
+Update Content-ID settings
+
+Update the Content-ID settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ContentIDSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ content_id_settings = scm.device_settings.ContentIdSettings() # ContentIdSettings | OK (optional)
+
+ try:
+ # Update Content-ID settings
+ api_response = api_instance.update_content_id_settings_by_id(id, content_id_settings=content_id_settings)
+ print("The response of ContentIDSettingsApi->update_content_id_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ContentIDSettingsApi->update_content_id_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **content_id_settings** | [**ContentIdSettings**](ContentIdSettings.md)| OK | [optional]
+
+### Return type
+
+[**ContentIdSettings**](ContentIdSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/ContentIdSettings.md b/scm/device_settings/docs/ContentIdSettings.md
new file mode 100644
index 00000000..23750ec8
--- /dev/null
+++ b/scm/device_settings/docs/ContentIdSettings.md
@@ -0,0 +1,33 @@
+# ContentIdSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**content_id** | [**ContentIdSettingsContentId**](ContentIdSettingsContentId.md) | | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ContentIdSettings from a JSON string
+content_id_settings_instance = ContentIdSettings.from_json(json)
+# print the JSON string representation of the object
+print(ContentIdSettings.to_json())
+
+# convert the object into a dict
+content_id_settings_dict = content_id_settings_instance.to_dict()
+# create an instance of ContentIdSettings from a dict
+content_id_settings_from_dict = ContentIdSettings.from_dict(content_id_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ContentIdSettingsContentId.md b/scm/device_settings/docs/ContentIdSettingsContentId.md
new file mode 100644
index 00000000..b95c8d6b
--- /dev/null
+++ b/scm/device_settings/docs/ContentIdSettingsContentId.md
@@ -0,0 +1,36 @@
+# ContentIdSettingsContentId
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**allow_forward_decrypted_content** | **bool** | | [optional] [default to False]
+**allow_http_range** | **bool** | | [optional] [default to True]
+**application** | [**ContentIdSettingsContentIdApplication**](ContentIdSettingsContentIdApplication.md) | | [optional]
+**extended_capture_segment** | **int** | | [optional] [default to 5]
+**strip_x_fwd_for** | **bool** | | [optional] [default to False]
+**tcp_bypass_exceed_queue** | **bool** | | [optional] [default to True]
+**udp_bypass_exceed_queue** | **bool** | | [optional] [default to True]
+**x_forwarded_for** | **str** | | [optional] [default to '0']
+
+## Example
+
+```python
+from scm.device_settings.models.content_id_settings_content_id import ContentIdSettingsContentId
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ContentIdSettingsContentId from a JSON string
+content_id_settings_content_id_instance = ContentIdSettingsContentId.from_json(json)
+# print the JSON string representation of the object
+print(ContentIdSettingsContentId.to_json())
+
+# convert the object into a dict
+content_id_settings_content_id_dict = content_id_settings_content_id_instance.to_dict()
+# create an instance of ContentIdSettingsContentId from a dict
+content_id_settings_content_id_from_dict = ContentIdSettingsContentId.from_dict(content_id_settings_content_id_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ContentIdSettingsContentIdApplication.md b/scm/device_settings/docs/ContentIdSettingsContentIdApplication.md
new file mode 100644
index 00000000..b27da647
--- /dev/null
+++ b/scm/device_settings/docs/ContentIdSettingsContentIdApplication.md
@@ -0,0 +1,29 @@
+# ContentIdSettingsContentIdApplication
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bypass_exceed_queue** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.content_id_settings_content_id_application import ContentIdSettingsContentIdApplication
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ContentIdSettingsContentIdApplication from a JSON string
+content_id_settings_content_id_application_instance = ContentIdSettingsContentIdApplication.from_json(json)
+# print the JSON string representation of the object
+print(ContentIdSettingsContentIdApplication.to_json())
+
+# convert the object into a dict
+content_id_settings_content_id_application_dict = content_id_settings_content_id_application_instance.to_dict()
+# create an instance of ContentIdSettingsContentIdApplication from a dict
+content_id_settings_content_id_application_from_dict = ContentIdSettingsContentIdApplication.from_dict(content_id_settings_content_id_application_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/DeviceRedistributionCollector.md b/scm/device_settings/docs/DeviceRedistributionCollector.md
new file mode 100644
index 00000000..5db786d1
--- /dev/null
+++ b/scm/device_settings/docs/DeviceRedistributionCollector.md
@@ -0,0 +1,33 @@
+# DeviceRedistributionCollector
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**redistribution_collector** | [**DeviceRedistributionCollectorRedistributionCollector**](DeviceRedistributionCollectorRedistributionCollector.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of DeviceRedistributionCollector from a JSON string
+device_redistribution_collector_instance = DeviceRedistributionCollector.from_json(json)
+# print the JSON string representation of the object
+print(DeviceRedistributionCollector.to_json())
+
+# convert the object into a dict
+device_redistribution_collector_dict = device_redistribution_collector_instance.to_dict()
+# create an instance of DeviceRedistributionCollector from a dict
+device_redistribution_collector_from_dict = DeviceRedistributionCollector.from_dict(device_redistribution_collector_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/DeviceRedistributionCollectorRedistributionCollector.md b/scm/device_settings/docs/DeviceRedistributionCollectorRedistributionCollector.md
new file mode 100644
index 00000000..19bdcce8
--- /dev/null
+++ b/scm/device_settings/docs/DeviceRedistributionCollectorRedistributionCollector.md
@@ -0,0 +1,29 @@
+# DeviceRedistributionCollectorRedistributionCollector
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**interface** | **str** | User-ID collector interface | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.device_redistribution_collector_redistribution_collector import DeviceRedistributionCollectorRedistributionCollector
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of DeviceRedistributionCollectorRedistributionCollector from a JSON string
+device_redistribution_collector_redistribution_collector_instance = DeviceRedistributionCollectorRedistributionCollector.from_json(json)
+# print the JSON string representation of the object
+print(DeviceRedistributionCollectorRedistributionCollector.to_json())
+
+# convert the object into a dict
+device_redistribution_collector_redistribution_collector_dict = device_redistribution_collector_redistribution_collector_instance.to_dict()
+# create an instance of DeviceRedistributionCollectorRedistributionCollector from a dict
+device_redistribution_collector_redistribution_collector_from_dict = DeviceRedistributionCollectorRedistributionCollector.from_dict(device_redistribution_collector_redistribution_collector_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/DeviceRedistributionCollectorSettingsApi.md b/scm/device_settings/docs/DeviceRedistributionCollectorSettingsApi.md
new file mode 100644
index 00000000..902f4323
--- /dev/null
+++ b/scm/device_settings/docs/DeviceRedistributionCollectorSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.DeviceRedistributionCollectorSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_device_redistribution_collector_settings**](DeviceRedistributionCollectorSettingsApi.md#create_device_redistribution_collector_settings) | **POST** /device-redistribution-collector | Create device redistribution collector settings
+[**delete_device_redistribution_collector_settings_by_id**](DeviceRedistributionCollectorSettingsApi.md#delete_device_redistribution_collector_settings_by_id) | **DELETE** /device-redistribution-collector/{id} | Delete device redistribution collector settings
+[**get_device_redistribution_collector_settings_by_id**](DeviceRedistributionCollectorSettingsApi.md#get_device_redistribution_collector_settings_by_id) | **GET** /device-redistribution-collector/{id} | Get existing device redistribution collector settings
+[**list_device_redistribution_collector_settings**](DeviceRedistributionCollectorSettingsApi.md#list_device_redistribution_collector_settings) | **GET** /device-redistribution-collector | List device redistribution collector settings
+[**update_device_redistribution_collector_settings_by_id**](DeviceRedistributionCollectorSettingsApi.md#update_device_redistribution_collector_settings_by_id) | **PUT** /device-redistribution-collector/{id} | Update device redistribution collector settings
+
+
+# **create_device_redistribution_collector_settings**
+> DeviceRedistributionCollector create_device_redistribution_collector_settings(device_redistribution_collector=device_redistribution_collector)
+
+Create device redistribution collector settings
+
+Create new device redistribution collector settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.DeviceRedistributionCollectorSettingsApi(api_client)
+ device_redistribution_collector = scm.device_settings.DeviceRedistributionCollector() # DeviceRedistributionCollector | (optional)
+
+ try:
+ # Create device redistribution collector settings
+ api_response = api_instance.create_device_redistribution_collector_settings(device_redistribution_collector=device_redistribution_collector)
+ print("The response of DeviceRedistributionCollectorSettingsApi->create_device_redistribution_collector_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling DeviceRedistributionCollectorSettingsApi->create_device_redistribution_collector_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **device_redistribution_collector** | [**DeviceRedistributionCollector**](DeviceRedistributionCollector.md)| | [optional]
+
+### Return type
+
+[**DeviceRedistributionCollector**](DeviceRedistributionCollector.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_device_redistribution_collector_settings_by_id**
+> delete_device_redistribution_collector_settings_by_id(id)
+
+Delete device redistribution collector settings
+
+Delete the device redistribution collector settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.DeviceRedistributionCollectorSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete device redistribution collector settings
+ api_instance.delete_device_redistribution_collector_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling DeviceRedistributionCollectorSettingsApi->delete_device_redistribution_collector_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_device_redistribution_collector_settings_by_id**
+> DeviceRedistributionCollector get_device_redistribution_collector_settings_by_id(id)
+
+Get existing device redistribution collector settings
+
+Retrieve existing device redistribution collector settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.DeviceRedistributionCollectorSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing device redistribution collector settings
+ api_response = api_instance.get_device_redistribution_collector_settings_by_id(id)
+ print("The response of DeviceRedistributionCollectorSettingsApi->get_device_redistribution_collector_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling DeviceRedistributionCollectorSettingsApi->get_device_redistribution_collector_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**DeviceRedistributionCollector**](DeviceRedistributionCollector.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_device_redistribution_collector_settings**
+> List[DeviceRedistributionCollector] list_device_redistribution_collector_settings(folder=folder, snippet=snippet, device=device)
+
+List device redistribution collector settings
+
+Retrieve a list of device redistribution collector settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.DeviceRedistributionCollectorSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List device redistribution collector settings
+ api_response = api_instance.list_device_redistribution_collector_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of DeviceRedistributionCollectorSettingsApi->list_device_redistribution_collector_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling DeviceRedistributionCollectorSettingsApi->list_device_redistribution_collector_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[DeviceRedistributionCollector]**](DeviceRedistributionCollector.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_device_redistribution_collector_settings_by_id**
+> DeviceRedistributionCollector update_device_redistribution_collector_settings_by_id(id, device_redistribution_collector=device_redistribution_collector)
+
+Update device redistribution collector settings
+
+Update the device redistribution collector settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.DeviceRedistributionCollectorSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ device_redistribution_collector = scm.device_settings.DeviceRedistributionCollector() # DeviceRedistributionCollector | OK (optional)
+
+ try:
+ # Update device redistribution collector settings
+ api_response = api_instance.update_device_redistribution_collector_settings_by_id(id, device_redistribution_collector=device_redistribution_collector)
+ print("The response of DeviceRedistributionCollectorSettingsApi->update_device_redistribution_collector_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling DeviceRedistributionCollectorSettingsApi->update_device_redistribution_collector_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **device_redistribution_collector** | [**DeviceRedistributionCollector**](DeviceRedistributionCollector.md)| OK | [optional]
+
+### Return type
+
+[**DeviceRedistributionCollector**](DeviceRedistributionCollector.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/ErrorDetailCauseInfo.md b/scm/device_settings/docs/ErrorDetailCauseInfo.md
new file mode 100644
index 00000000..5d2c78c1
--- /dev/null
+++ b/scm/device_settings/docs/ErrorDetailCauseInfo.md
@@ -0,0 +1,32 @@
+# ErrorDetailCauseInfo
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **str** | | [optional]
+**details** | **object** | | [optional]
+**help** | **str** | | [optional]
+**message** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.error_detail_cause_info import ErrorDetailCauseInfo
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ErrorDetailCauseInfo from a JSON string
+error_detail_cause_info_instance = ErrorDetailCauseInfo.from_json(json)
+# print the JSON string representation of the object
+print(ErrorDetailCauseInfo.to_json())
+
+# convert the object into a dict
+error_detail_cause_info_dict = error_detail_cause_info_instance.to_dict()
+# create an instance of ErrorDetailCauseInfo from a dict
+error_detail_cause_info_from_dict = ErrorDetailCauseInfo.from_dict(error_detail_cause_info_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/GeneralSettings.md b/scm/device_settings/docs/GeneralSettings.md
new file mode 100644
index 00000000..25fe7b6c
--- /dev/null
+++ b/scm/device_settings/docs/GeneralSettings.md
@@ -0,0 +1,33 @@
+# GeneralSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**general** | [**GeneralSettingsGeneral**](GeneralSettingsGeneral.md) | | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.general_settings import GeneralSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GeneralSettings from a JSON string
+general_settings_instance = GeneralSettings.from_json(json)
+# print the JSON string representation of the object
+print(GeneralSettings.to_json())
+
+# convert the object into a dict
+general_settings_dict = general_settings_instance.to_dict()
+# create an instance of GeneralSettings from a dict
+general_settings_from_dict = GeneralSettings.from_dict(general_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/GeneralSettingsApi.md b/scm/device_settings/docs/GeneralSettingsApi.md
new file mode 100644
index 00000000..69dc5f59
--- /dev/null
+++ b/scm/device_settings/docs/GeneralSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.GeneralSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_general_settings**](GeneralSettingsApi.md#create_general_settings) | **POST** /general-settings | Create general settings
+[**delete_general_settings_by_id**](GeneralSettingsApi.md#delete_general_settings_by_id) | **DELETE** /general-settings/{id} | Delete general settings
+[**get_general_settings_by_id**](GeneralSettingsApi.md#get_general_settings_by_id) | **GET** /general-settings/{id} | Get existing general settings
+[**list_general_settings**](GeneralSettingsApi.md#list_general_settings) | **GET** /general-settings | List general settings
+[**update_general_settings_by_id**](GeneralSettingsApi.md#update_general_settings_by_id) | **PUT** /general-settings/{id} | Update general settings
+
+
+# **create_general_settings**
+> GeneralSettings create_general_settings(general_settings=general_settings)
+
+Create general settings
+
+Create new general settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.general_settings import GeneralSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.GeneralSettingsApi(api_client)
+ general_settings = scm.device_settings.GeneralSettings() # GeneralSettings | (optional)
+
+ try:
+ # Create general settings
+ api_response = api_instance.create_general_settings(general_settings=general_settings)
+ print("The response of GeneralSettingsApi->create_general_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling GeneralSettingsApi->create_general_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **general_settings** | [**GeneralSettings**](GeneralSettings.md)| | [optional]
+
+### Return type
+
+[**GeneralSettings**](GeneralSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_general_settings_by_id**
+> delete_general_settings_by_id(id)
+
+Delete general settings
+
+Delete the general settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.GeneralSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete general settings
+ api_instance.delete_general_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling GeneralSettingsApi->delete_general_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_general_settings_by_id**
+> GeneralSettings get_general_settings_by_id(id)
+
+Get existing general settings
+
+Retrieve existing general settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.general_settings import GeneralSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.GeneralSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing general settings
+ api_response = api_instance.get_general_settings_by_id(id)
+ print("The response of GeneralSettingsApi->get_general_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling GeneralSettingsApi->get_general_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**GeneralSettings**](GeneralSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_general_settings**
+> List[GeneralSettings] list_general_settings(folder=folder, snippet=snippet, device=device)
+
+List general settings
+
+Retrieve a list of general settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.general_settings import GeneralSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.GeneralSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List general settings
+ api_response = api_instance.list_general_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of GeneralSettingsApi->list_general_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling GeneralSettingsApi->list_general_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[GeneralSettings]**](GeneralSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_general_settings_by_id**
+> GeneralSettings update_general_settings_by_id(id, general_settings=general_settings)
+
+Update general settings
+
+Update the device redistribution collector settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.general_settings import GeneralSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.GeneralSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ general_settings = scm.device_settings.GeneralSettings() # GeneralSettings | OK (optional)
+
+ try:
+ # Update general settings
+ api_response = api_instance.update_general_settings_by_id(id, general_settings=general_settings)
+ print("The response of GeneralSettingsApi->update_general_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling GeneralSettingsApi->update_general_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **general_settings** | [**GeneralSettings**](GeneralSettings.md)| OK | [optional]
+
+### Return type
+
+[**GeneralSettings**](GeneralSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/GeneralSettingsGeneral.md b/scm/device_settings/docs/GeneralSettingsGeneral.md
new file mode 100644
index 00000000..8f0eaad0
--- /dev/null
+++ b/scm/device_settings/docs/GeneralSettingsGeneral.md
@@ -0,0 +1,36 @@
+# GeneralSettingsGeneral
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ack_login_banner** | **bool** | Force admins to acknowledge login banner | [optional] [default to False]
+**domain** | **str** | DNS domain | [optional]
+**geo_location** | [**GeneralSettingsGeneralGeoLocation**](GeneralSettingsGeneralGeoLocation.md) | | [optional]
+**locale** | **str** | Locale | [optional] [default to 'en']
+**login_banner** | **str** | Logon banner | [optional]
+**setting** | [**GeneralSettingsGeneralSetting**](GeneralSettingsGeneralSetting.md) | | [optional]
+**ssl_tls_service_profile** | **str** | SSL/TLS service profile | [optional]
+**timezone** | **str** | Timezone | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.general_settings_general import GeneralSettingsGeneral
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GeneralSettingsGeneral from a JSON string
+general_settings_general_instance = GeneralSettingsGeneral.from_json(json)
+# print the JSON string representation of the object
+print(GeneralSettingsGeneral.to_json())
+
+# convert the object into a dict
+general_settings_general_dict = general_settings_general_instance.to_dict()
+# create an instance of GeneralSettingsGeneral from a dict
+general_settings_general_from_dict = GeneralSettingsGeneral.from_dict(general_settings_general_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/GeneralSettingsGeneralGeoLocation.md b/scm/device_settings/docs/GeneralSettingsGeneralGeoLocation.md
new file mode 100644
index 00000000..7f144097
--- /dev/null
+++ b/scm/device_settings/docs/GeneralSettingsGeneralGeoLocation.md
@@ -0,0 +1,31 @@
+# GeneralSettingsGeneralGeoLocation
+
+Geographic coordinates
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**latitude** | **str** | Latitude | [optional]
+**longitude** | **str** | Longitude | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.general_settings_general_geo_location import GeneralSettingsGeneralGeoLocation
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GeneralSettingsGeneralGeoLocation from a JSON string
+general_settings_general_geo_location_instance = GeneralSettingsGeneralGeoLocation.from_json(json)
+# print the JSON string representation of the object
+print(GeneralSettingsGeneralGeoLocation.to_json())
+
+# convert the object into a dict
+general_settings_general_geo_location_dict = general_settings_general_geo_location_instance.to_dict()
+# create an instance of GeneralSettingsGeneralGeoLocation from a dict
+general_settings_general_geo_location_from_dict = GeneralSettingsGeneralGeoLocation.from_dict(general_settings_general_geo_location_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/GeneralSettingsGeneralSetting.md b/scm/device_settings/docs/GeneralSettingsGeneralSetting.md
new file mode 100644
index 00000000..45c6a549
--- /dev/null
+++ b/scm/device_settings/docs/GeneralSettingsGeneralSetting.md
@@ -0,0 +1,32 @@
+# GeneralSettingsGeneralSetting
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**auto_mac_detect** | **bool** | Use hypervisor assigned MAC addresses | [optional] [default to False]
+**fail_open** | **bool** | Fail open | [optional] [default to False]
+**management** | [**GeneralSettingsGeneralSettingManagement**](GeneralSettingsGeneralSettingManagement.md) | | [optional]
+**tunnel_acceleration** | **bool** | Tunnel acceleration | [optional] [default to True]
+
+## Example
+
+```python
+from scm.device_settings.models.general_settings_general_setting import GeneralSettingsGeneralSetting
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GeneralSettingsGeneralSetting from a JSON string
+general_settings_general_setting_instance = GeneralSettingsGeneralSetting.from_json(json)
+# print the JSON string representation of the object
+print(GeneralSettingsGeneralSetting.to_json())
+
+# convert the object into a dict
+general_settings_general_setting_dict = general_settings_general_setting_instance.to_dict()
+# create an instance of GeneralSettingsGeneralSetting from a dict
+general_settings_general_setting_from_dict = GeneralSettingsGeneralSetting.from_dict(general_settings_general_setting_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/GeneralSettingsGeneralSettingManagement.md b/scm/device_settings/docs/GeneralSettingsGeneralSettingManagement.md
new file mode 100644
index 00000000..add6e28e
--- /dev/null
+++ b/scm/device_settings/docs/GeneralSettingsGeneralSettingManagement.md
@@ -0,0 +1,30 @@
+# GeneralSettingsGeneralSettingManagement
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**auto_acquire_commit_lock** | **bool** | Automatically acquire commit lock | [optional] [default to False]
+**enable_certificate_expiration_check** | **bool** | Certificate expiration check | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.general_settings_general_setting_management import GeneralSettingsGeneralSettingManagement
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GeneralSettingsGeneralSettingManagement from a JSON string
+general_settings_general_setting_management_instance = GeneralSettingsGeneralSettingManagement.from_json(json)
+# print the JSON string representation of the object
+print(GeneralSettingsGeneralSettingManagement.to_json())
+
+# convert the object into a dict
+general_settings_general_setting_management_dict = general_settings_general_setting_management_instance.to_dict()
+# create an instance of GeneralSettingsGeneralSettingManagement from a dict
+general_settings_general_setting_management_from_dict = GeneralSettingsGeneralSettingManagement.from_dict(general_settings_general_setting_management_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/GenericError.md b/scm/device_settings/docs/GenericError.md
new file mode 100644
index 00000000..af9dcf7f
--- /dev/null
+++ b/scm/device_settings/docs/GenericError.md
@@ -0,0 +1,30 @@
+# GenericError
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**errors** | [**List[ErrorDetailCauseInfo]**](ErrorDetailCauseInfo.md) | | [optional]
+**request_id** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.generic_error import GenericError
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GenericError from a JSON string
+generic_error_instance = GenericError.from_json(json)
+# print the JSON string representation of the object
+print(GenericError.to_json())
+
+# convert the object into a dict
+generic_error_dict = generic_error_instance.to_dict()
+# create an instance of GenericError from a dict
+generic_error_from_dict = GenericError.from_dict(generic_error_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurations.md b/scm/device_settings/docs/HaConfigurations.md
new file mode 100644
index 00000000..bf09719b
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurations.md
@@ -0,0 +1,34 @@
+# HaConfigurations
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**enabled** | **bool** | | [optional] [default to True]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**group** | [**HaConfigurationsGroup**](HaConfigurationsGroup.md) | |
+**interface** | [**HaConfigurationsInterface**](HaConfigurationsInterface.md) | |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations import HaConfigurations
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurations from a JSON string
+ha_configurations_instance = HaConfigurations.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurations.to_json())
+
+# convert the object into a dict
+ha_configurations_dict = ha_configurations_instance.to_dict()
+# create an instance of HaConfigurations from a dict
+ha_configurations_from_dict = HaConfigurations.from_dict(ha_configurations_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroup.md b/scm/device_settings/docs/HaConfigurationsGroup.md
new file mode 100644
index 00000000..31573c7f
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroup.md
@@ -0,0 +1,37 @@
+# HaConfigurationsGroup
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | HA group description (not currently used) | [optional] [default to 'N/A']
+**election_option** | [**HaConfigurationsGroupElectionOption**](HaConfigurationsGroupElectionOption.md) | |
+**group_id** | **int** | HA group ID |
+**mode** | [**HaConfigurationsGroupMode**](HaConfigurationsGroupMode.md) | |
+**monitoring** | [**HaConfigurationsGroupMonitoring**](HaConfigurationsGroupMonitoring.md) | |
+**peer_ip** | **str** | Peer HA1 IP address |
+**peer_ip_backup** | **str** | Peer HA1 backup IP address | [optional]
+**peer_serial** | **str** | Serial number of the HA peer |
+**state_synchronization** | [**HaConfigurationsGroupStateSynchronization**](HaConfigurationsGroupStateSynchronization.md) | |
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group import HaConfigurationsGroup
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroup from a JSON string
+ha_configurations_group_instance = HaConfigurationsGroup.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroup.to_json())
+
+# convert the object into a dict
+ha_configurations_group_dict = ha_configurations_group_instance.to_dict()
+# create an instance of HaConfigurationsGroup from a dict
+ha_configurations_group_from_dict = HaConfigurationsGroup.from_dict(ha_configurations_group_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupElectionOption.md b/scm/device_settings/docs/HaConfigurationsGroupElectionOption.md
new file mode 100644
index 00000000..229fcdfb
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupElectionOption.md
@@ -0,0 +1,32 @@
+# HaConfigurationsGroupElectionOption
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device_priority** | **int** | Device priority (1 = primary, 2 = secondary) | [optional]
+**ha_role** | **str** | Device HA role | [optional]
+**heartbeat_backup** | **bool** | | [optional]
+**preemptive** | **bool** | Preemption enabled? | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_election_option import HaConfigurationsGroupElectionOption
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupElectionOption from a JSON string
+ha_configurations_group_election_option_instance = HaConfigurationsGroupElectionOption.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupElectionOption.to_json())
+
+# convert the object into a dict
+ha_configurations_group_election_option_dict = ha_configurations_group_election_option_instance.to_dict()
+# create an instance of HaConfigurationsGroupElectionOption from a dict
+ha_configurations_group_election_option_from_dict = HaConfigurationsGroupElectionOption.from_dict(ha_configurations_group_election_option_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMode.md b/scm/device_settings/docs/HaConfigurationsGroupMode.md
new file mode 100644
index 00000000..d68d34eb
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMode.md
@@ -0,0 +1,29 @@
+# HaConfigurationsGroupMode
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**active_passive** | [**HaConfigurationsGroupModeActivePassive**](HaConfigurationsGroupModeActivePassive.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_mode import HaConfigurationsGroupMode
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMode from a JSON string
+ha_configurations_group_mode_instance = HaConfigurationsGroupMode.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMode.to_json())
+
+# convert the object into a dict
+ha_configurations_group_mode_dict = ha_configurations_group_mode_instance.to_dict()
+# create an instance of HaConfigurationsGroupMode from a dict
+ha_configurations_group_mode_from_dict = HaConfigurationsGroupMode.from_dict(ha_configurations_group_mode_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupModeActivePassive.md b/scm/device_settings/docs/HaConfigurationsGroupModeActivePassive.md
new file mode 100644
index 00000000..35402cdd
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupModeActivePassive.md
@@ -0,0 +1,30 @@
+# HaConfigurationsGroupModeActivePassive
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**monitor_fail_hold_down_time** | **int** | Monitor hold time (milliseconds) | [optional] [default to 3000]
+**passive_link_state** | **str** | Passive link state | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_mode_active_passive import HaConfigurationsGroupModeActivePassive
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupModeActivePassive from a JSON string
+ha_configurations_group_mode_active_passive_instance = HaConfigurationsGroupModeActivePassive.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupModeActivePassive.to_json())
+
+# convert the object into a dict
+ha_configurations_group_mode_active_passive_dict = ha_configurations_group_mode_active_passive_instance.to_dict()
+# create an instance of HaConfigurationsGroupModeActivePassive from a dict
+ha_configurations_group_mode_active_passive_from_dict = HaConfigurationsGroupModeActivePassive.from_dict(ha_configurations_group_mode_active_passive_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMonitoring.md b/scm/device_settings/docs/HaConfigurationsGroupMonitoring.md
new file mode 100644
index 00000000..8a689542
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMonitoring.md
@@ -0,0 +1,30 @@
+# HaConfigurationsGroupMonitoring
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**link_monitoring** | [**HaConfigurationsGroupMonitoringLinkMonitoring**](HaConfigurationsGroupMonitoringLinkMonitoring.md) | | [optional]
+**path_monitoring** | [**HaConfigurationsGroupMonitoringPathMonitoring**](HaConfigurationsGroupMonitoringPathMonitoring.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_monitoring import HaConfigurationsGroupMonitoring
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMonitoring from a JSON string
+ha_configurations_group_monitoring_instance = HaConfigurationsGroupMonitoring.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMonitoring.to_json())
+
+# convert the object into a dict
+ha_configurations_group_monitoring_dict = ha_configurations_group_monitoring_instance.to_dict()
+# create an instance of HaConfigurationsGroupMonitoring from a dict
+ha_configurations_group_monitoring_from_dict = HaConfigurationsGroupMonitoring.from_dict(ha_configurations_group_monitoring_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMonitoringLinkMonitoring.md b/scm/device_settings/docs/HaConfigurationsGroupMonitoringLinkMonitoring.md
new file mode 100644
index 00000000..555ffc8c
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMonitoringLinkMonitoring.md
@@ -0,0 +1,31 @@
+# HaConfigurationsGroupMonitoringLinkMonitoring
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**enabled** | **bool** | Enable link monitoring | [optional] [default to False]
+**failure_condition** | **str** | Failure condition | [optional]
+**link_group** | [**List[HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner]**](HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.md) | Link groups | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring import HaConfigurationsGroupMonitoringLinkMonitoring
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMonitoringLinkMonitoring from a JSON string
+ha_configurations_group_monitoring_link_monitoring_instance = HaConfigurationsGroupMonitoringLinkMonitoring.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMonitoringLinkMonitoring.to_json())
+
+# convert the object into a dict
+ha_configurations_group_monitoring_link_monitoring_dict = ha_configurations_group_monitoring_link_monitoring_instance.to_dict()
+# create an instance of HaConfigurationsGroupMonitoringLinkMonitoring from a dict
+ha_configurations_group_monitoring_link_monitoring_from_dict = HaConfigurationsGroupMonitoringLinkMonitoring.from_dict(ha_configurations_group_monitoring_link_monitoring_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.md b/scm/device_settings/docs/HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.md
new file mode 100644
index 00000000..e9686def
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.md
@@ -0,0 +1,32 @@
+# HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**enabled** | **bool** | Enable link group? | [optional] [default to True]
+**failure_condition** | **str** | Failure condition | [optional]
+**interface** | **List[str]** | Interfaces monitored | [optional]
+**name** | **str** | Link group name |
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring_link_group_inner import HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner from a JSON string
+ha_configurations_group_monitoring_link_monitoring_link_group_inner_instance = HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.to_json())
+
+# convert the object into a dict
+ha_configurations_group_monitoring_link_monitoring_link_group_inner_dict = ha_configurations_group_monitoring_link_monitoring_link_group_inner_instance.to_dict()
+# create an instance of HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner from a dict
+ha_configurations_group_monitoring_link_monitoring_link_group_inner_from_dict = HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.from_dict(ha_configurations_group_monitoring_link_monitoring_link_group_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoring.md b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoring.md
new file mode 100644
index 00000000..93aa779c
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoring.md
@@ -0,0 +1,31 @@
+# HaConfigurationsGroupMonitoringPathMonitoring
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**enabled** | **bool** | Enable path monitoring? | [optional] [default to False]
+**failure_condition** | **str** | | [optional]
+**path_group** | [**HaConfigurationsGroupMonitoringPathMonitoringPathGroup**](HaConfigurationsGroupMonitoringPathMonitoringPathGroup.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring import HaConfigurationsGroupMonitoringPathMonitoring
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoring from a JSON string
+ha_configurations_group_monitoring_path_monitoring_instance = HaConfigurationsGroupMonitoringPathMonitoring.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMonitoringPathMonitoring.to_json())
+
+# convert the object into a dict
+ha_configurations_group_monitoring_path_monitoring_dict = ha_configurations_group_monitoring_path_monitoring_instance.to_dict()
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoring from a dict
+ha_configurations_group_monitoring_path_monitoring_from_dict = HaConfigurationsGroupMonitoringPathMonitoring.from_dict(ha_configurations_group_monitoring_path_monitoring_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroup.md b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroup.md
new file mode 100644
index 00000000..13251a88
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroup.md
@@ -0,0 +1,29 @@
+# HaConfigurationsGroupMonitoringPathMonitoringPathGroup
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**logical_router** | [**List[HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner]**](HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.md) | Logical router | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group import HaConfigurationsGroupMonitoringPathMonitoringPathGroup
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroup from a JSON string
+ha_configurations_group_monitoring_path_monitoring_path_group_instance = HaConfigurationsGroupMonitoringPathMonitoringPathGroup.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMonitoringPathMonitoringPathGroup.to_json())
+
+# convert the object into a dict
+ha_configurations_group_monitoring_path_monitoring_path_group_dict = ha_configurations_group_monitoring_path_monitoring_path_group_instance.to_dict()
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroup from a dict
+ha_configurations_group_monitoring_path_monitoring_path_group_from_dict = HaConfigurationsGroupMonitoringPathMonitoringPathGroup.from_dict(ha_configurations_group_monitoring_path_monitoring_path_group_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.md b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.md
new file mode 100644
index 00000000..13cba0fd
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.md
@@ -0,0 +1,34 @@
+# HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**destination_ip_group** | [**List[HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner]**](HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.md) | | [optional]
+**enabled** | **bool** | Enable path group? | [optional] [default to True]
+**failure_condition** | **str** | Failure condition | [optional]
+**name** | **str** | Logical router name |
+**ping_count** | **int** | Ping count | [optional] [default to 10]
+**ping_interval** | **int** | Ping interval | [optional] [default to 200]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner from a JSON string
+ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_instance = HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.to_json())
+
+# convert the object into a dict
+ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_dict = ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_instance.to_dict()
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner from a dict
+ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_from_dict = HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.from_dict(ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.md b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.md
new file mode 100644
index 00000000..74dc302b
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.md
@@ -0,0 +1,32 @@
+# HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**destination_ip** | **List[str]** | Destination IP addresses | [optional]
+**enabled** | **bool** | Enable destination IP group? | [optional]
+**failure_condition** | **str** | Failure condition | [optional]
+**name** | **str** | Destination IP group name |
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner from a JSON string
+ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner_instance = HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.to_json())
+
+# convert the object into a dict
+ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner_dict = ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner_instance.to_dict()
+# create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner from a dict
+ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner_from_dict = HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.from_dict(ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupStateSynchronization.md b/scm/device_settings/docs/HaConfigurationsGroupStateSynchronization.md
new file mode 100644
index 00000000..46d90fb6
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupStateSynchronization.md
@@ -0,0 +1,31 @@
+# HaConfigurationsGroupStateSynchronization
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**enabled** | **bool** | Enable session synchronization | [optional]
+**ha2_keep_alive** | [**HaConfigurationsGroupStateSynchronizationHa2KeepAlive**](HaConfigurationsGroupStateSynchronizationHa2KeepAlive.md) | | [optional]
+**transport** | **str** | Session synchronization transport | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_state_synchronization import HaConfigurationsGroupStateSynchronization
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupStateSynchronization from a JSON string
+ha_configurations_group_state_synchronization_instance = HaConfigurationsGroupStateSynchronization.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupStateSynchronization.to_json())
+
+# convert the object into a dict
+ha_configurations_group_state_synchronization_dict = ha_configurations_group_state_synchronization_instance.to_dict()
+# create an instance of HaConfigurationsGroupStateSynchronization from a dict
+ha_configurations_group_state_synchronization_from_dict = HaConfigurationsGroupStateSynchronization.from_dict(ha_configurations_group_state_synchronization_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsGroupStateSynchronizationHa2KeepAlive.md b/scm/device_settings/docs/HaConfigurationsGroupStateSynchronizationHa2KeepAlive.md
new file mode 100644
index 00000000..90cad210
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsGroupStateSynchronizationHa2KeepAlive.md
@@ -0,0 +1,31 @@
+# HaConfigurationsGroupStateSynchronizationHa2KeepAlive
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | Keep-alive action | [optional]
+**enabled** | **bool** | Enable HA2 keep-alives? | [optional] [default to False]
+**threshold** | **int** | Keep-alive threshold (milliseconds) | [optional] [default to 10000]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_group_state_synchronization_ha2_keep_alive import HaConfigurationsGroupStateSynchronizationHa2KeepAlive
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsGroupStateSynchronizationHa2KeepAlive from a JSON string
+ha_configurations_group_state_synchronization_ha2_keep_alive_instance = HaConfigurationsGroupStateSynchronizationHa2KeepAlive.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsGroupStateSynchronizationHa2KeepAlive.to_json())
+
+# convert the object into a dict
+ha_configurations_group_state_synchronization_ha2_keep_alive_dict = ha_configurations_group_state_synchronization_ha2_keep_alive_instance.to_dict()
+# create an instance of HaConfigurationsGroupStateSynchronizationHa2KeepAlive from a dict
+ha_configurations_group_state_synchronization_ha2_keep_alive_from_dict = HaConfigurationsGroupStateSynchronizationHa2KeepAlive.from_dict(ha_configurations_group_state_synchronization_ha2_keep_alive_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsInterface.md b/scm/device_settings/docs/HaConfigurationsInterface.md
new file mode 100644
index 00000000..28906c14
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsInterface.md
@@ -0,0 +1,32 @@
+# HaConfigurationsInterface
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ha1** | [**HaConfigurationsInterfaceHa1**](HaConfigurationsInterfaceHa1.md) | |
+**ha1_backup** | [**HaConfigurationsInterfaceHa1Backup**](HaConfigurationsInterfaceHa1Backup.md) | | [optional]
+**ha2** | [**HaConfigurationsInterfaceHa2**](HaConfigurationsInterfaceHa2.md) | |
+**ha2_backup** | [**HaConfigurationsInterfaceHa2Backup**](HaConfigurationsInterfaceHa2Backup.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_interface import HaConfigurationsInterface
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsInterface from a JSON string
+ha_configurations_interface_instance = HaConfigurationsInterface.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsInterface.to_json())
+
+# convert the object into a dict
+ha_configurations_interface_dict = ha_configurations_interface_instance.to_dict()
+# create an instance of HaConfigurationsInterface from a dict
+ha_configurations_interface_from_dict = HaConfigurationsInterface.from_dict(ha_configurations_interface_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsInterfaceHa1.md b/scm/device_settings/docs/HaConfigurationsInterfaceHa1.md
new file mode 100644
index 00000000..8d87f885
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsInterfaceHa1.md
@@ -0,0 +1,33 @@
+# HaConfigurationsInterfaceHa1
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**gateway** | **str** | HA1 default gateway | [optional]
+**ip_address** | **str** | HA1 IP address | [optional]
+**monitor_hold_time** | **int** | HA1 monitor hold time | [default to 3000]
+**netmask** | **str** | HA1 netmask | [optional]
+**port** | **str** | HA1 port |
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_interface_ha1 import HaConfigurationsInterfaceHa1
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsInterfaceHa1 from a JSON string
+ha_configurations_interface_ha1_instance = HaConfigurationsInterfaceHa1.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsInterfaceHa1.to_json())
+
+# convert the object into a dict
+ha_configurations_interface_ha1_dict = ha_configurations_interface_ha1_instance.to_dict()
+# create an instance of HaConfigurationsInterfaceHa1 from a dict
+ha_configurations_interface_ha1_from_dict = HaConfigurationsInterfaceHa1.from_dict(ha_configurations_interface_ha1_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsInterfaceHa1Backup.md b/scm/device_settings/docs/HaConfigurationsInterfaceHa1Backup.md
new file mode 100644
index 00000000..c7426962
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsInterfaceHa1Backup.md
@@ -0,0 +1,32 @@
+# HaConfigurationsInterfaceHa1Backup
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**gateway** | **str** | HA1 backup default gateway | [optional]
+**ip_address** | **str** | HA1 backup IP address | [optional]
+**netmask** | **str** | HA1 backup netmask | [optional]
+**port** | **str** | HA1 backup port | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_interface_ha1_backup import HaConfigurationsInterfaceHa1Backup
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsInterfaceHa1Backup from a JSON string
+ha_configurations_interface_ha1_backup_instance = HaConfigurationsInterfaceHa1Backup.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsInterfaceHa1Backup.to_json())
+
+# convert the object into a dict
+ha_configurations_interface_ha1_backup_dict = ha_configurations_interface_ha1_backup_instance.to_dict()
+# create an instance of HaConfigurationsInterfaceHa1Backup from a dict
+ha_configurations_interface_ha1_backup_from_dict = HaConfigurationsInterfaceHa1Backup.from_dict(ha_configurations_interface_ha1_backup_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsInterfaceHa2.md b/scm/device_settings/docs/HaConfigurationsInterfaceHa2.md
new file mode 100644
index 00000000..c4f7069f
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsInterfaceHa2.md
@@ -0,0 +1,32 @@
+# HaConfigurationsInterfaceHa2
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**gateway** | **str** | HA2 default gateway | [optional]
+**ip_address** | **str** | HA2 IP address |
+**netmask** | **str** | HA2 netmask |
+**port** | **str** | HA2 port |
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_interface_ha2 import HaConfigurationsInterfaceHa2
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsInterfaceHa2 from a JSON string
+ha_configurations_interface_ha2_instance = HaConfigurationsInterfaceHa2.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsInterfaceHa2.to_json())
+
+# convert the object into a dict
+ha_configurations_interface_ha2_dict = ha_configurations_interface_ha2_instance.to_dict()
+# create an instance of HaConfigurationsInterfaceHa2 from a dict
+ha_configurations_interface_ha2_from_dict = HaConfigurationsInterfaceHa2.from_dict(ha_configurations_interface_ha2_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaConfigurationsInterfaceHa2Backup.md b/scm/device_settings/docs/HaConfigurationsInterfaceHa2Backup.md
new file mode 100644
index 00000000..fd468145
--- /dev/null
+++ b/scm/device_settings/docs/HaConfigurationsInterfaceHa2Backup.md
@@ -0,0 +1,32 @@
+# HaConfigurationsInterfaceHa2Backup
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**gateway** | **str** | HA2 backup default gateway | [optional]
+**ip_address** | **str** | HA2 backup IP address | [optional]
+**netmask** | **str** | HA2 backup netmask | [optional]
+**port** | **str** | HA2 backup port | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_configurations_interface_ha2_backup import HaConfigurationsInterfaceHa2Backup
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaConfigurationsInterfaceHa2Backup from a JSON string
+ha_configurations_interface_ha2_backup_instance = HaConfigurationsInterfaceHa2Backup.from_json(json)
+# print the JSON string representation of the object
+print(HaConfigurationsInterfaceHa2Backup.to_json())
+
+# convert the object into a dict
+ha_configurations_interface_ha2_backup_dict = ha_configurations_interface_ha2_backup_instance.to_dict()
+# create an instance of HaConfigurationsInterfaceHa2Backup from a dict
+ha_configurations_interface_ha2_backup_from_dict = HaConfigurationsInterfaceHa2Backup.from_dict(ha_configurations_interface_ha2_backup_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaDevices.md b/scm/device_settings/docs/HaDevices.md
new file mode 100644
index 00000000..5cdcfb68
--- /dev/null
+++ b/scm/device_settings/docs/HaDevices.md
@@ -0,0 +1,32 @@
+# HaDevices
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**ha_devices** | [**List[HaDevicesHaDevicesInner]**](HaDevicesHaDevicesInner.md) | HA devices | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_devices import HaDevices
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaDevices from a JSON string
+ha_devices_instance = HaDevices.from_json(json)
+# print the JSON string representation of the object
+print(HaDevices.to_json())
+
+# convert the object into a dict
+ha_devices_dict = ha_devices_instance.to_dict()
+# create an instance of HaDevices from a dict
+ha_devices_from_dict = HaDevices.from_dict(ha_devices_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HaDevicesHaDevicesInner.md b/scm/device_settings/docs/HaDevicesHaDevicesInner.md
new file mode 100644
index 00000000..22ee1394
--- /dev/null
+++ b/scm/device_settings/docs/HaDevicesHaDevicesInner.md
@@ -0,0 +1,32 @@
+# HaDevicesHaDevicesInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**primary_device_name** | **str** | Primary device name | [optional]
+**primary_serial_number** | **str** | Primary device serial number | [optional]
+**secondary_device_name** | **str** | Secondary device name | [optional]
+**secondary_serial_number** | **str** | Secondary device serial number | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.ha_devices_ha_devices_inner import HaDevicesHaDevicesInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of HaDevicesHaDevicesInner from a JSON string
+ha_devices_ha_devices_inner_instance = HaDevicesHaDevicesInner.from_json(json)
+# print the JSON string representation of the object
+print(HaDevicesHaDevicesInner.to_json())
+
+# convert the object into a dict
+ha_devices_ha_devices_inner_dict = ha_devices_ha_devices_inner_instance.to_dict()
+# create an instance of HaDevicesHaDevicesInner from a dict
+ha_devices_ha_devices_inner_from_dict = HaDevicesHaDevicesInner.from_dict(ha_devices_ha_devices_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/HighAvailabilityDevicesApi.md b/scm/device_settings/docs/HighAvailabilityDevicesApi.md
new file mode 100644
index 00000000..9cf82167
--- /dev/null
+++ b/scm/device_settings/docs/HighAvailabilityDevicesApi.md
@@ -0,0 +1,96 @@
+# scm.device_settings.HighAvailabilityDevicesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**list_ha_devices**](HighAvailabilityDevicesApi.md#list_ha_devices) | **GET** /ha-devices | List high availability devices
+
+
+# **list_ha_devices**
+> ListHADevices200Response list_ha_devices(folder=folder, snippet=snippet, device=device)
+
+List high availability devices
+
+Retrieve a list of high availability devices.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.list_ha_devices200_response import ListHADevices200Response
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.HighAvailabilityDevicesApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List high availability devices
+ api_response = api_instance.list_ha_devices(folder=folder, snippet=snippet, device=device)
+ print("The response of HighAvailabilityDevicesApi->list_ha_devices:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling HighAvailabilityDevicesApi->list_ha_devices: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**ListHADevices200Response**](ListHADevices200Response.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/ListHADevices200Response.md b/scm/device_settings/docs/ListHADevices200Response.md
new file mode 100644
index 00000000..61abee76
--- /dev/null
+++ b/scm/device_settings/docs/ListHADevices200Response.md
@@ -0,0 +1,29 @@
+# ListHADevices200Response
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[HaDevices]**](HaDevices.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.list_ha_devices200_response import ListHADevices200Response
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ListHADevices200Response from a JSON string
+list_ha_devices200_response_instance = ListHADevices200Response.from_json(json)
+# print the JSON string representation of the object
+print(ListHADevices200Response.to_json())
+
+# convert the object into a dict
+list_ha_devices200_response_dict = list_ha_devices200_response_instance.to_dict()
+# create an instance of ListHADevices200Response from a dict
+list_ha_devices200_response_from_dict = ListHADevices200Response.from_dict(list_ha_devices200_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/LoginBannerSettingsApi.md b/scm/device_settings/docs/LoginBannerSettingsApi.md
new file mode 100644
index 00000000..64f293bf
--- /dev/null
+++ b/scm/device_settings/docs/LoginBannerSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.LoginBannerSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_login_banner_settings**](LoginBannerSettingsApi.md#create_login_banner_settings) | **POST** /motd-banner-settings | Create login banner settings
+[**delete_login_banner_settings_by_id**](LoginBannerSettingsApi.md#delete_login_banner_settings_by_id) | **DELETE** /motd-banner-settings/{id} | Delete login banner settings
+[**get_login_banner_settings_by_id**](LoginBannerSettingsApi.md#get_login_banner_settings_by_id) | **GET** /motd-banner-settings/{id} | Get existing login banner settings
+[**list_login_banner_settings**](LoginBannerSettingsApi.md#list_login_banner_settings) | **GET** /motd-banner-settings | List login banner settings
+[**update_login_banner_settings_by_id**](LoginBannerSettingsApi.md#update_login_banner_settings_by_id) | **PUT** /motd-banner-settings/{id} | Update login banner settings
+
+
+# **create_login_banner_settings**
+> MotdBannerSettings create_login_banner_settings(motd_banner_settings=motd_banner_settings)
+
+Create login banner settings
+
+Create new login banner settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.LoginBannerSettingsApi(api_client)
+ motd_banner_settings = scm.device_settings.MotdBannerSettings() # MotdBannerSettings | (optional)
+
+ try:
+ # Create login banner settings
+ api_response = api_instance.create_login_banner_settings(motd_banner_settings=motd_banner_settings)
+ print("The response of LoginBannerSettingsApi->create_login_banner_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LoginBannerSettingsApi->create_login_banner_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **motd_banner_settings** | [**MotdBannerSettings**](MotdBannerSettings.md)| | [optional]
+
+### Return type
+
+[**MotdBannerSettings**](MotdBannerSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_login_banner_settings_by_id**
+> delete_login_banner_settings_by_id(id)
+
+Delete login banner settings
+
+Delete the login banner settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.LoginBannerSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete login banner settings
+ api_instance.delete_login_banner_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling LoginBannerSettingsApi->delete_login_banner_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_login_banner_settings_by_id**
+> MotdBannerSettings get_login_banner_settings_by_id(id)
+
+Get existing login banner settings
+
+Retrieve existing login banner settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.LoginBannerSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing login banner settings
+ api_response = api_instance.get_login_banner_settings_by_id(id)
+ print("The response of LoginBannerSettingsApi->get_login_banner_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LoginBannerSettingsApi->get_login_banner_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**MotdBannerSettings**](MotdBannerSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_login_banner_settings**
+> List[MotdBannerSettings] list_login_banner_settings(folder=folder, snippet=snippet, device=device)
+
+List login banner settings
+
+Retrieve a list of login banner settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.LoginBannerSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List login banner settings
+ api_response = api_instance.list_login_banner_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of LoginBannerSettingsApi->list_login_banner_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LoginBannerSettingsApi->list_login_banner_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[MotdBannerSettings]**](MotdBannerSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_login_banner_settings_by_id**
+> MotdBannerSettings update_login_banner_settings_by_id(id, motd_banner_settings=motd_banner_settings)
+
+Update login banner settings
+
+Update the login banner settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.LoginBannerSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ motd_banner_settings = scm.device_settings.MotdBannerSettings() # MotdBannerSettings | OK (optional)
+
+ try:
+ # Update login banner settings
+ api_response = api_instance.update_login_banner_settings_by_id(id, motd_banner_settings=motd_banner_settings)
+ print("The response of LoginBannerSettingsApi->update_login_banner_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LoginBannerSettingsApi->update_login_banner_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **motd_banner_settings** | [**MotdBannerSettings**](MotdBannerSettings.md)| OK | [optional]
+
+### Return type
+
+[**MotdBannerSettings**](MotdBannerSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/ManagementInterface.md b/scm/device_settings/docs/ManagementInterface.md
new file mode 100644
index 00000000..4de68126
--- /dev/null
+++ b/scm/device_settings/docs/ManagementInterface.md
@@ -0,0 +1,33 @@
+# ManagementInterface
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**management_interface** | [**ManagementInterfaceManagementInterface**](ManagementInterfaceManagementInterface.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.management_interface import ManagementInterface
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ManagementInterface from a JSON string
+management_interface_instance = ManagementInterface.from_json(json)
+# print the JSON string representation of the object
+print(ManagementInterface.to_json())
+
+# convert the object into a dict
+management_interface_dict = management_interface_instance.to_dict()
+# create an instance of ManagementInterface from a dict
+management_interface_from_dict = ManagementInterface.from_dict(management_interface_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ManagementInterfaceManagementInterface.md b/scm/device_settings/docs/ManagementInterfaceManagementInterface.md
new file mode 100644
index 00000000..9977fba5
--- /dev/null
+++ b/scm/device_settings/docs/ManagementInterfaceManagementInterface.md
@@ -0,0 +1,36 @@
+# ManagementInterfaceManagementInterface
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**default_gateway** | **str** | Default gateway | [optional]
+**ip_address** | **str** | IP address | [optional]
+**mgmt_type** | [**ManagementInterfaceManagementInterfaceMgmtType**](ManagementInterfaceManagementInterfaceMgmtType.md) | | [optional]
+**mtu** | **int** | MTU | [optional] [default to 1500]
+**netmask** | **str** | Netmask | [optional]
+**permitted_ip** | [**List[ManagementInterfaceManagementInterfacePermittedIpInner]**](ManagementInterfaceManagementInterfacePermittedIpInner.md) | Permitting IP addresses | [optional]
+**service** | [**ManagementInterfaceManagementInterfaceService**](ManagementInterfaceManagementInterfaceService.md) | | [optional]
+**speed_duplex** | **str** | Speed and duplex | [optional] [default to 'auto-negotiate']
+
+## Example
+
+```python
+from scm.device_settings.models.management_interface_management_interface import ManagementInterfaceManagementInterface
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ManagementInterfaceManagementInterface from a JSON string
+management_interface_management_interface_instance = ManagementInterfaceManagementInterface.from_json(json)
+# print the JSON string representation of the object
+print(ManagementInterfaceManagementInterface.to_json())
+
+# convert the object into a dict
+management_interface_management_interface_dict = management_interface_management_interface_instance.to_dict()
+# create an instance of ManagementInterfaceManagementInterface from a dict
+management_interface_management_interface_from_dict = ManagementInterfaceManagementInterface.from_dict(management_interface_management_interface_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ManagementInterfaceManagementInterfaceMgmtType.md b/scm/device_settings/docs/ManagementInterfaceManagementInterfaceMgmtType.md
new file mode 100644
index 00000000..00ad5c49
--- /dev/null
+++ b/scm/device_settings/docs/ManagementInterfaceManagementInterfaceMgmtType.md
@@ -0,0 +1,31 @@
+# ManagementInterfaceManagementInterfaceMgmtType
+
+IP type
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**dhcp_client** | [**ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient**](ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.md) | | [optional]
+**static** | **object** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.management_interface_management_interface_mgmt_type import ManagementInterfaceManagementInterfaceMgmtType
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ManagementInterfaceManagementInterfaceMgmtType from a JSON string
+management_interface_management_interface_mgmt_type_instance = ManagementInterfaceManagementInterfaceMgmtType.from_json(json)
+# print the JSON string representation of the object
+print(ManagementInterfaceManagementInterfaceMgmtType.to_json())
+
+# convert the object into a dict
+management_interface_management_interface_mgmt_type_dict = management_interface_management_interface_mgmt_type_instance.to_dict()
+# create an instance of ManagementInterfaceManagementInterfaceMgmtType from a dict
+management_interface_management_interface_mgmt_type_from_dict = ManagementInterfaceManagementInterfaceMgmtType.from_dict(management_interface_management_interface_mgmt_type_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.md b/scm/device_settings/docs/ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.md
new file mode 100644
index 00000000..3ed65fad
--- /dev/null
+++ b/scm/device_settings/docs/ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.md
@@ -0,0 +1,32 @@
+# ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**accept_dhcp_domain** | **bool** | Accept DHCP server provided domain name | [optional] [default to False]
+**accept_dhcp_hostname** | **bool** | Accept DHCP server provided hostname | [optional] [default to False]
+**send_client_id** | **bool** | Send client ID | [optional] [default to False]
+**send_hostname** | **bool** | Send hostname | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.management_interface_management_interface_mgmt_type_dhcp_client import ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient from a JSON string
+management_interface_management_interface_mgmt_type_dhcp_client_instance = ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.from_json(json)
+# print the JSON string representation of the object
+print(ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.to_json())
+
+# convert the object into a dict
+management_interface_management_interface_mgmt_type_dhcp_client_dict = management_interface_management_interface_mgmt_type_dhcp_client_instance.to_dict()
+# create an instance of ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient from a dict
+management_interface_management_interface_mgmt_type_dhcp_client_from_dict = ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.from_dict(management_interface_management_interface_mgmt_type_dhcp_client_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ManagementInterfaceManagementInterfacePermittedIpInner.md b/scm/device_settings/docs/ManagementInterfaceManagementInterfacePermittedIpInner.md
new file mode 100644
index 00000000..85537384
--- /dev/null
+++ b/scm/device_settings/docs/ManagementInterfaceManagementInterfacePermittedIpInner.md
@@ -0,0 +1,30 @@
+# ManagementInterfaceManagementInterfacePermittedIpInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**description** | **str** | Description | [optional]
+**name** | **str** | IP address | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.management_interface_management_interface_permitted_ip_inner import ManagementInterfaceManagementInterfacePermittedIpInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ManagementInterfaceManagementInterfacePermittedIpInner from a JSON string
+management_interface_management_interface_permitted_ip_inner_instance = ManagementInterfaceManagementInterfacePermittedIpInner.from_json(json)
+# print the JSON string representation of the object
+print(ManagementInterfaceManagementInterfacePermittedIpInner.to_json())
+
+# convert the object into a dict
+management_interface_management_interface_permitted_ip_inner_dict = management_interface_management_interface_permitted_ip_inner_instance.to_dict()
+# create an instance of ManagementInterfaceManagementInterfacePermittedIpInner from a dict
+management_interface_management_interface_permitted_ip_inner_from_dict = ManagementInterfaceManagementInterfacePermittedIpInner.from_dict(management_interface_management_interface_permitted_ip_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ManagementInterfaceManagementInterfaceService.md b/scm/device_settings/docs/ManagementInterfaceManagementInterfaceService.md
new file mode 100644
index 00000000..25601b12
--- /dev/null
+++ b/scm/device_settings/docs/ManagementInterfaceManagementInterfaceService.md
@@ -0,0 +1,39 @@
+# ManagementInterfaceManagementInterfaceService
+
+Network services
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**disable_http** | **bool** | HTTP | [optional] [default to False]
+**disable_http_ocsp** | **bool** | HTTP OCSP | [optional] [default to False]
+**disable_https** | **bool** | HTTPS | [optional] [default to True]
+**disable_icmp** | **bool** | Ping | [optional] [default to False]
+**disable_snmp** | **bool** | SNMP | [optional] [default to False]
+**disable_ssh** | **bool** | SSH | [optional] [default to True]
+**disable_telnet** | **bool** | Telnet | [optional] [default to False]
+**disable_userid_service** | **bool** | User-ID | [optional] [default to False]
+**disable_userid_syslog_listener_ssl** | **bool** | User-ID syslog listener over SSL | [optional] [default to False]
+**disable_userid_syslog_listener_udp** | **bool** | User-ID syslog listener over UDP | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.management_interface_management_interface_service import ManagementInterfaceManagementInterfaceService
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ManagementInterfaceManagementInterfaceService from a JSON string
+management_interface_management_interface_service_instance = ManagementInterfaceManagementInterfaceService.from_json(json)
+# print the JSON string representation of the object
+print(ManagementInterfaceManagementInterfaceService.to_json())
+
+# convert the object into a dict
+management_interface_management_interface_service_dict = management_interface_management_interface_service_instance.to_dict()
+# create an instance of ManagementInterfaceManagementInterfaceService from a dict
+management_interface_management_interface_service_from_dict = ManagementInterfaceManagementInterfaceService.from_dict(management_interface_management_interface_service_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ManagementInterfaceSettingsApi.md b/scm/device_settings/docs/ManagementInterfaceSettingsApi.md
new file mode 100644
index 00000000..61ee5841
--- /dev/null
+++ b/scm/device_settings/docs/ManagementInterfaceSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.ManagementInterfaceSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_management_interface_settings**](ManagementInterfaceSettingsApi.md#create_management_interface_settings) | **POST** /management-interface | Create management interface settings
+[**delete_management_interface_settings_by_id**](ManagementInterfaceSettingsApi.md#delete_management_interface_settings_by_id) | **DELETE** /management-interface/{id} | Delete management interface settings
+[**get_management_interface_settings_by_id**](ManagementInterfaceSettingsApi.md#get_management_interface_settings_by_id) | **GET** /management-interface/{id} | Get existing management interface settings
+[**list_management_interface_settings**](ManagementInterfaceSettingsApi.md#list_management_interface_settings) | **GET** /management-interface | List management interface settings
+[**update_management_interface_settings_by_id**](ManagementInterfaceSettingsApi.md#update_management_interface_settings_by_id) | **PUT** /management-interface/{id} | Update management interface settings
+
+
+# **create_management_interface_settings**
+> ManagementInterface create_management_interface_settings(management_interface=management_interface)
+
+Create management interface settings
+
+Create new management interface settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.management_interface import ManagementInterface
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ManagementInterfaceSettingsApi(api_client)
+ management_interface = scm.device_settings.ManagementInterface() # ManagementInterface | (optional)
+
+ try:
+ # Create management interface settings
+ api_response = api_instance.create_management_interface_settings(management_interface=management_interface)
+ print("The response of ManagementInterfaceSettingsApi->create_management_interface_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ManagementInterfaceSettingsApi->create_management_interface_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **management_interface** | [**ManagementInterface**](ManagementInterface.md)| | [optional]
+
+### Return type
+
+[**ManagementInterface**](ManagementInterface.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_management_interface_settings_by_id**
+> delete_management_interface_settings_by_id(id)
+
+Delete management interface settings
+
+Delete the management interface settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ManagementInterfaceSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete management interface settings
+ api_instance.delete_management_interface_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling ManagementInterfaceSettingsApi->delete_management_interface_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_management_interface_settings_by_id**
+> ManagementInterface get_management_interface_settings_by_id(id)
+
+Get existing management interface settings
+
+Retrieve existing management interface settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.management_interface import ManagementInterface
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ManagementInterfaceSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing management interface settings
+ api_response = api_instance.get_management_interface_settings_by_id(id)
+ print("The response of ManagementInterfaceSettingsApi->get_management_interface_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ManagementInterfaceSettingsApi->get_management_interface_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**ManagementInterface**](ManagementInterface.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_management_interface_settings**
+> List[ManagementInterface] list_management_interface_settings(folder=folder, snippet=snippet, device=device)
+
+List management interface settings
+
+Retrieve a list of management interface settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.management_interface import ManagementInterface
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ManagementInterfaceSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List management interface settings
+ api_response = api_instance.list_management_interface_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of ManagementInterfaceSettingsApi->list_management_interface_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ManagementInterfaceSettingsApi->list_management_interface_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[ManagementInterface]**](ManagementInterface.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_management_interface_settings_by_id**
+> ManagementInterface update_management_interface_settings_by_id(id, management_interface=management_interface)
+
+Update management interface settings
+
+Update the management interface settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.management_interface import ManagementInterface
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ManagementInterfaceSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ management_interface = scm.device_settings.ManagementInterface() # ManagementInterface | OK (optional)
+
+ try:
+ # Update management interface settings
+ api_response = api_instance.update_management_interface_settings_by_id(id, management_interface=management_interface)
+ print("The response of ManagementInterfaceSettingsApi->update_management_interface_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ManagementInterfaceSettingsApi->update_management_interface_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **management_interface** | [**ManagementInterface**](ManagementInterface.md)| OK | [optional]
+
+### Return type
+
+[**ManagementInterface**](ManagementInterface.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/MotdBannerSettings.md b/scm/device_settings/docs/MotdBannerSettings.md
new file mode 100644
index 00000000..565ab18d
--- /dev/null
+++ b/scm/device_settings/docs/MotdBannerSettings.md
@@ -0,0 +1,33 @@
+# MotdBannerSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**motd_and_banner** | [**MotdBannerSettingsMotdAndBanner**](MotdBannerSettingsMotdAndBanner.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MotdBannerSettings from a JSON string
+motd_banner_settings_instance = MotdBannerSettings.from_json(json)
+# print the JSON string representation of the object
+print(MotdBannerSettings.to_json())
+
+# convert the object into a dict
+motd_banner_settings_dict = motd_banner_settings_instance.to_dict()
+# create an instance of MotdBannerSettings from a dict
+motd_banner_settings_from_dict = MotdBannerSettings.from_dict(motd_banner_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/MotdBannerSettingsMotdAndBanner.md b/scm/device_settings/docs/MotdBannerSettingsMotdAndBanner.md
new file mode 100644
index 00000000..fb956ab0
--- /dev/null
+++ b/scm/device_settings/docs/MotdBannerSettingsMotdAndBanner.md
@@ -0,0 +1,41 @@
+# MotdBannerSettingsMotdAndBanner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**banner_footer** | **str** | | [optional]
+**banner_footer_color** | [**MotdColor**](MotdColor.md) | | [optional]
+**banner_footer_text_color** | [**MotdColor**](MotdColor.md) | | [optional]
+**banner_header** | **str** | | [optional]
+**banner_header_color** | [**MotdColor**](MotdColor.md) | | [optional]
+**banner_header_footer_match** | **bool** | | [optional]
+**banner_header_text_color** | [**MotdColor**](MotdColor.md) | | [optional]
+**message** | **str** | | [optional]
+**motd_color** | [**MotdColor**](MotdColor.md) | | [optional]
+**motd_do_not_display_again** | **bool** | | [optional]
+**motd_enable** | **bool** | | [optional]
+**motd_title** | **str** | | [optional]
+**severity** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.motd_banner_settings_motd_and_banner import MotdBannerSettingsMotdAndBanner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MotdBannerSettingsMotdAndBanner from a JSON string
+motd_banner_settings_motd_and_banner_instance = MotdBannerSettingsMotdAndBanner.from_json(json)
+# print the JSON string representation of the object
+print(MotdBannerSettingsMotdAndBanner.to_json())
+
+# convert the object into a dict
+motd_banner_settings_motd_and_banner_dict = motd_banner_settings_motd_and_banner_instance.to_dict()
+# create an instance of MotdBannerSettingsMotdAndBanner from a dict
+motd_banner_settings_motd_and_banner_from_dict = MotdBannerSettingsMotdAndBanner.from_dict(motd_banner_settings_motd_and_banner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/MotdColor.md b/scm/device_settings/docs/MotdColor.md
new file mode 100644
index 00000000..2bb5decb
--- /dev/null
+++ b/scm/device_settings/docs/MotdColor.md
@@ -0,0 +1,43 @@
+# MotdColor
+
+The following list details the supported values and their colors. - `color1` = Red - `color2` = Green - `color3` = Blue - `color4` = Yellow - `color5` = Copper - `color6` = Orange - `color7` = Purple - `color8` = Gray - `color9` = Light Green - `color10` = Cyan - `color11` = Light Gray - `color12` = Blue Gray - `color13` = Lime - `color14` = Black - `color15` = Gold - `color16` = Brown - `color17` = Olive
+
+## Enum
+
+* `COLOR1` (value: `'color1'`)
+
+* `COLOR2` (value: `'color2'`)
+
+* `COLOR3` (value: `'color3'`)
+
+* `COLOR4` (value: `'color4'`)
+
+* `COLOR5` (value: `'color5'`)
+
+* `COLOR6` (value: `'color6'`)
+
+* `COLOR7` (value: `'color7'`)
+
+* `COLOR8` (value: `'color8'`)
+
+* `COLOR9` (value: `'color9'`)
+
+* `COLOR10` (value: `'color10'`)
+
+* `COLOR11` (value: `'color11'`)
+
+* `COLOR12` (value: `'color12'`)
+
+* `COLOR13` (value: `'color13'`)
+
+* `COLOR14` (value: `'color14'`)
+
+* `COLOR15` (value: `'color15'`)
+
+* `COLOR16` (value: `'color16'`)
+
+* `COLOR17` (value: `'color17'`)
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRoute.md b/scm/device_settings/docs/ServiceRoute.md
new file mode 100644
index 00000000..5538ccad
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRoute.md
@@ -0,0 +1,33 @@
+# ServiceRoute
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**route** | [**ServiceRouteRoute**](ServiceRouteRoute.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_route import ServiceRoute
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceRoute from a JSON string
+service_route_instance = ServiceRoute.from_json(json)
+# print the JSON string representation of the object
+print(ServiceRoute.to_json())
+
+# convert the object into a dict
+service_route_dict = service_route_instance.to_dict()
+# create an instance of ServiceRoute from a dict
+service_route_from_dict = ServiceRoute.from_dict(service_route_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRouteRoute.md b/scm/device_settings/docs/ServiceRouteRoute.md
new file mode 100644
index 00000000..73c9d6fa
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRouteRoute.md
@@ -0,0 +1,30 @@
+# ServiceRouteRoute
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**destination** | [**List[ServiceRouteRouteDestinationInner]**](ServiceRouteRouteDestinationInner.md) | | [optional]
+**service** | [**List[ServiceRouteRouteServiceInner]**](ServiceRouteRouteServiceInner.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_route_route import ServiceRouteRoute
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceRouteRoute from a JSON string
+service_route_route_instance = ServiceRouteRoute.from_json(json)
+# print the JSON string representation of the object
+print(ServiceRouteRoute.to_json())
+
+# convert the object into a dict
+service_route_route_dict = service_route_route_instance.to_dict()
+# create an instance of ServiceRouteRoute from a dict
+service_route_route_from_dict = ServiceRouteRoute.from_dict(service_route_route_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRouteRouteDestinationInner.md b/scm/device_settings/docs/ServiceRouteRouteDestinationInner.md
new file mode 100644
index 00000000..837b477a
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRouteRouteDestinationInner.md
@@ -0,0 +1,30 @@
+# ServiceRouteRouteDestinationInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**name** | **str** | | [optional]
+**source** | [**ServiceRouteRouteDestinationInnerSource**](ServiceRouteRouteDestinationInnerSource.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_route_route_destination_inner import ServiceRouteRouteDestinationInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceRouteRouteDestinationInner from a JSON string
+service_route_route_destination_inner_instance = ServiceRouteRouteDestinationInner.from_json(json)
+# print the JSON string representation of the object
+print(ServiceRouteRouteDestinationInner.to_json())
+
+# convert the object into a dict
+service_route_route_destination_inner_dict = service_route_route_destination_inner_instance.to_dict()
+# create an instance of ServiceRouteRouteDestinationInner from a dict
+service_route_route_destination_inner_from_dict = ServiceRouteRouteDestinationInner.from_dict(service_route_route_destination_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRouteRouteDestinationInnerSource.md b/scm/device_settings/docs/ServiceRouteRouteDestinationInnerSource.md
new file mode 100644
index 00000000..89473eaf
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRouteRouteDestinationInnerSource.md
@@ -0,0 +1,30 @@
+# ServiceRouteRouteDestinationInnerSource
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**address** | **str** | | [optional]
+**interface** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_route_route_destination_inner_source import ServiceRouteRouteDestinationInnerSource
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceRouteRouteDestinationInnerSource from a JSON string
+service_route_route_destination_inner_source_instance = ServiceRouteRouteDestinationInnerSource.from_json(json)
+# print the JSON string representation of the object
+print(ServiceRouteRouteDestinationInnerSource.to_json())
+
+# convert the object into a dict
+service_route_route_destination_inner_source_dict = service_route_route_destination_inner_source_instance.to_dict()
+# create an instance of ServiceRouteRouteDestinationInnerSource from a dict
+service_route_route_destination_inner_source_from_dict = ServiceRouteRouteDestinationInnerSource.from_dict(service_route_route_destination_inner_source_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRouteRouteServiceInner.md b/scm/device_settings/docs/ServiceRouteRouteServiceInner.md
new file mode 100644
index 00000000..40873a56
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRouteRouteServiceInner.md
@@ -0,0 +1,31 @@
+# ServiceRouteRouteServiceInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**name** | **str** | The follow list details the accepted `name` values and their corresponding service description. - `autofocus` = AutoFocus Cloud - `crl-status` = CRL servers - `data-services` = Data Services - `ddns` = DDNS server(s) - `deployments` = Panorama pushed updates - `dns` = DNS server(s) - `edl-updates` = External Dynamic List update server - `email` = SMTP gateway(s) - `hsm` = Hardware Security Module server(s) - `http` = HTTP Forwarding server(s) - `iot` = IOT service-route - `kerberos` = Kerberos server - `ldap` = LDAP server - `mdm` = MDM servers - `mfa` = Multi-Factor Authentication - `netflow` = Netflow server(s) - `ntp` = NTP server(s) - `paloalto-networks-services` = Palo Alto Networks Services - `panorama` = Panorama server - `panorama-log-forwarding` = Panorama Log Forwarding - `proxy` = Proxy server - `radius` = RADIUS server - `scep` = SCEP - `snmp` = SNMP server(s) - `syslog` = Syslog server(s) - `tacplus` = TACACS+ server - `uid-`agent = UID agent(s) - `url-`updates = URL update server - `vmmonitor` = VM monitor - `wildfire-`private = WildFire Appliance - `ztp` = ZTP and Auto-VPN DDNS | [optional]
+**source** | [**ServiceRouteRouteServiceInnerSource**](ServiceRouteRouteServiceInnerSource.md) | | [optional]
+**source_v6** | [**ServiceRouteRouteServiceInnerSourceV6**](ServiceRouteRouteServiceInnerSourceV6.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_route_route_service_inner import ServiceRouteRouteServiceInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceRouteRouteServiceInner from a JSON string
+service_route_route_service_inner_instance = ServiceRouteRouteServiceInner.from_json(json)
+# print the JSON string representation of the object
+print(ServiceRouteRouteServiceInner.to_json())
+
+# convert the object into a dict
+service_route_route_service_inner_dict = service_route_route_service_inner_instance.to_dict()
+# create an instance of ServiceRouteRouteServiceInner from a dict
+service_route_route_service_inner_from_dict = ServiceRouteRouteServiceInner.from_dict(service_route_route_service_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRouteRouteServiceInnerSource.md b/scm/device_settings/docs/ServiceRouteRouteServiceInnerSource.md
new file mode 100644
index 00000000..8452ec4a
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRouteRouteServiceInnerSource.md
@@ -0,0 +1,30 @@
+# ServiceRouteRouteServiceInnerSource
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**address** | **str** | | [optional]
+**interface** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_route_route_service_inner_source import ServiceRouteRouteServiceInnerSource
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceRouteRouteServiceInnerSource from a JSON string
+service_route_route_service_inner_source_instance = ServiceRouteRouteServiceInnerSource.from_json(json)
+# print the JSON string representation of the object
+print(ServiceRouteRouteServiceInnerSource.to_json())
+
+# convert the object into a dict
+service_route_route_service_inner_source_dict = service_route_route_service_inner_source_instance.to_dict()
+# create an instance of ServiceRouteRouteServiceInnerSource from a dict
+service_route_route_service_inner_source_from_dict = ServiceRouteRouteServiceInnerSource.from_dict(service_route_route_service_inner_source_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRouteRouteServiceInnerSourceV6.md b/scm/device_settings/docs/ServiceRouteRouteServiceInnerSourceV6.md
new file mode 100644
index 00000000..00e3274e
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRouteRouteServiceInnerSourceV6.md
@@ -0,0 +1,30 @@
+# ServiceRouteRouteServiceInnerSourceV6
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**address** | **str** | | [optional]
+**interface** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_route_route_service_inner_source_v6 import ServiceRouteRouteServiceInnerSourceV6
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceRouteRouteServiceInnerSourceV6 from a JSON string
+service_route_route_service_inner_source_v6_instance = ServiceRouteRouteServiceInnerSourceV6.from_json(json)
+# print the JSON string representation of the object
+print(ServiceRouteRouteServiceInnerSourceV6.to_json())
+
+# convert the object into a dict
+service_route_route_service_inner_source_v6_dict = service_route_route_service_inner_source_v6_instance.to_dict()
+# create an instance of ServiceRouteRouteServiceInnerSourceV6 from a dict
+service_route_route_service_inner_source_v6_from_dict = ServiceRouteRouteServiceInnerSourceV6.from_dict(service_route_route_service_inner_source_v6_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceRouteSettingsApi.md b/scm/device_settings/docs/ServiceRouteSettingsApi.md
new file mode 100644
index 00000000..00b1b56e
--- /dev/null
+++ b/scm/device_settings/docs/ServiceRouteSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.ServiceRouteSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_service_route_settings**](ServiceRouteSettingsApi.md#create_service_route_settings) | **POST** /service-route | Create service route settings
+[**delete_service_route_settings_by_id**](ServiceRouteSettingsApi.md#delete_service_route_settings_by_id) | **DELETE** /service-route/{id} | Delete service route settings
+[**get_service_route_settings_by_id**](ServiceRouteSettingsApi.md#get_service_route_settings_by_id) | **GET** /service-route/{id} | Get existing service route settings
+[**list_service_route_settings**](ServiceRouteSettingsApi.md#list_service_route_settings) | **GET** /service-route | List service route settings
+[**update_service_route_settings_by_id**](ServiceRouteSettingsApi.md#update_service_route_settings_by_id) | **PUT** /service-route/{id} | Update service route settings
+
+
+# **create_service_route_settings**
+> ServiceRoute create_service_route_settings(service_route=service_route)
+
+Create service route settings
+
+Create new service route settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_route import ServiceRoute
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceRouteSettingsApi(api_client)
+ service_route = scm.device_settings.ServiceRoute() # ServiceRoute | (optional)
+
+ try:
+ # Create service route settings
+ api_response = api_instance.create_service_route_settings(service_route=service_route)
+ print("The response of ServiceRouteSettingsApi->create_service_route_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceRouteSettingsApi->create_service_route_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **service_route** | [**ServiceRoute**](ServiceRoute.md)| | [optional]
+
+### Return type
+
+[**ServiceRoute**](ServiceRoute.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_service_route_settings_by_id**
+> delete_service_route_settings_by_id(id)
+
+Delete service route settings
+
+Delete the service route settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceRouteSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete service route settings
+ api_instance.delete_service_route_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling ServiceRouteSettingsApi->delete_service_route_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_service_route_settings_by_id**
+> ServiceRoute get_service_route_settings_by_id(id)
+
+Get existing service route settings
+
+Retrieve existing service route settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_route import ServiceRoute
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceRouteSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing service route settings
+ api_response = api_instance.get_service_route_settings_by_id(id)
+ print("The response of ServiceRouteSettingsApi->get_service_route_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceRouteSettingsApi->get_service_route_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**ServiceRoute**](ServiceRoute.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_service_route_settings**
+> List[ServiceRoute] list_service_route_settings(folder=folder, snippet=snippet, device=device)
+
+List service route settings
+
+Retrieve a list of service route settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_route import ServiceRoute
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceRouteSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List service route settings
+ api_response = api_instance.list_service_route_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of ServiceRouteSettingsApi->list_service_route_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceRouteSettingsApi->list_service_route_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[ServiceRoute]**](ServiceRoute.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_service_route_settings_by_id**
+> ServiceRoute update_service_route_settings_by_id(id, service_route=service_route)
+
+Update service route settings
+
+Update the service route settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_route import ServiceRoute
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceRouteSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ service_route = scm.device_settings.ServiceRoute() # ServiceRoute | OK (optional)
+
+ try:
+ # Update service route settings
+ api_response = api_instance.update_service_route_settings_by_id(id, service_route=service_route)
+ print("The response of ServiceRouteSettingsApi->update_service_route_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceRouteSettingsApi->update_service_route_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **service_route** | [**ServiceRoute**](ServiceRoute.md)| OK | [optional]
+
+### Return type
+
+[**ServiceRoute**](ServiceRoute.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/ServiceSettings.md b/scm/device_settings/docs/ServiceSettings.md
new file mode 100644
index 00000000..4ec2e8a2
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettings.md
@@ -0,0 +1,33 @@
+# ServiceSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**services** | [**ServiceSettingsServices**](ServiceSettingsServices.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings import ServiceSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettings from a JSON string
+service_settings_instance = ServiceSettings.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettings.to_json())
+
+# convert the object into a dict
+service_settings_dict = service_settings_instance.to_dict()
+# create an instance of ServiceSettings from a dict
+service_settings_from_dict = ServiceSettings.from_dict(service_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsApi.md b/scm/device_settings/docs/ServiceSettingsApi.md
new file mode 100644
index 00000000..fa7631fe
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.ServiceSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_service_settings**](ServiceSettingsApi.md#create_service_settings) | **POST** /service-settings | Create service settings
+[**delete_service_settings_by_id**](ServiceSettingsApi.md#delete_service_settings_by_id) | **DELETE** /service-settings/{id} | Delete service settings
+[**get_service_settings_by_id**](ServiceSettingsApi.md#get_service_settings_by_id) | **GET** /service-settings/{id} | Get existing service settings
+[**list_service_settings**](ServiceSettingsApi.md#list_service_settings) | **GET** /service-settings | List service settings
+[**update_service_settings_by_id**](ServiceSettingsApi.md#update_service_settings_by_id) | **PUT** /service-settings/{id} | Update service settings
+
+
+# **create_service_settings**
+> ServiceSettings create_service_settings(service_settings=service_settings)
+
+Create service settings
+
+Create new service settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_settings import ServiceSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceSettingsApi(api_client)
+ service_settings = scm.device_settings.ServiceSettings() # ServiceSettings | (optional)
+
+ try:
+ # Create service settings
+ api_response = api_instance.create_service_settings(service_settings=service_settings)
+ print("The response of ServiceSettingsApi->create_service_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceSettingsApi->create_service_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **service_settings** | [**ServiceSettings**](ServiceSettings.md)| | [optional]
+
+### Return type
+
+[**ServiceSettings**](ServiceSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_service_settings_by_id**
+> delete_service_settings_by_id(id)
+
+Delete service settings
+
+Delete the service settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete service settings
+ api_instance.delete_service_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling ServiceSettingsApi->delete_service_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_service_settings_by_id**
+> ServiceSettings get_service_settings_by_id(id)
+
+Get existing service settings
+
+Retrieve existing service settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_settings import ServiceSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing service settings
+ api_response = api_instance.get_service_settings_by_id(id)
+ print("The response of ServiceSettingsApi->get_service_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceSettingsApi->get_service_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**ServiceSettings**](ServiceSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_service_settings**
+> List[ServiceSettings] list_service_settings(folder=folder, snippet=snippet, device=device)
+
+List service settings
+
+Retrieve a list of service settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_settings import ServiceSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List service settings
+ api_response = api_instance.list_service_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of ServiceSettingsApi->list_service_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceSettingsApi->list_service_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[ServiceSettings]**](ServiceSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_service_settings_by_id**
+> ServiceSettings update_service_settings_by_id(id, service_settings=service_settings)
+
+Update service settings
+
+Update the service settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.service_settings import ServiceSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.ServiceSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ service_settings = scm.device_settings.ServiceSettings() # ServiceSettings | OK (optional)
+
+ try:
+ # Update service settings
+ api_response = api_instance.update_service_settings_by_id(id, service_settings=service_settings)
+ print("The response of ServiceSettingsApi->update_service_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling ServiceSettingsApi->update_service_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **service_settings** | [**ServiceSettings**](ServiceSettings.md)| OK | [optional]
+
+### Return type
+
+[**ServiceSettings**](ServiceSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/ServiceSettingsServices.md b/scm/device_settings/docs/ServiceSettingsServices.md
new file mode 100644
index 00000000..e9d0116e
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServices.md
@@ -0,0 +1,40 @@
+# ServiceSettingsServices
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**dns_setting** | [**ServiceSettingsServicesDnsSetting**](ServiceSettingsServicesDnsSetting.md) | | [optional]
+**fqdn_refresh_time** | **float** | | [optional] [default to 15]
+**fqdn_stale_entry_timeout** | **float** | | [optional] [default to 1440]
+**inline_cloud_proxy** | **bool** | | [optional] [default to False]
+**lcaas_use_proxy** | **bool** | | [optional] [default to False]
+**ntp_servers** | [**ServiceSettingsServicesNtpServers**](ServiceSettingsServicesNtpServers.md) | | [optional]
+**secure_proxy_password** | **str** | | [optional]
+**secure_proxy_port** | **float** | | [optional]
+**secure_proxy_server** | **str** | | [optional]
+**secure_proxy_user** | **str** | | [optional]
+**server_verification** | **bool** | | [optional] [default to True]
+**update_server** | **str** | | [optional] [default to 'updates.paloaltonetworks.com']
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services import ServiceSettingsServices
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServices from a JSON string
+service_settings_services_instance = ServiceSettingsServices.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServices.to_json())
+
+# convert the object into a dict
+service_settings_services_dict = service_settings_services_instance.to_dict()
+# create an instance of ServiceSettingsServices from a dict
+service_settings_services_from_dict = ServiceSettingsServices.from_dict(service_settings_services_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesDnsSetting.md b/scm/device_settings/docs/ServiceSettingsServicesDnsSetting.md
new file mode 100644
index 00000000..53e357f8
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesDnsSetting.md
@@ -0,0 +1,30 @@
+# ServiceSettingsServicesDnsSetting
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**dns_proxy_object** | **str** | | [optional]
+**servers** | [**ServiceSettingsServicesDnsSettingServers**](ServiceSettingsServicesDnsSettingServers.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_dns_setting import ServiceSettingsServicesDnsSetting
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesDnsSetting from a JSON string
+service_settings_services_dns_setting_instance = ServiceSettingsServicesDnsSetting.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesDnsSetting.to_json())
+
+# convert the object into a dict
+service_settings_services_dns_setting_dict = service_settings_services_dns_setting_instance.to_dict()
+# create an instance of ServiceSettingsServicesDnsSetting from a dict
+service_settings_services_dns_setting_from_dict = ServiceSettingsServicesDnsSetting.from_dict(service_settings_services_dns_setting_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesDnsSettingServers.md b/scm/device_settings/docs/ServiceSettingsServicesDnsSettingServers.md
new file mode 100644
index 00000000..4f7263d2
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesDnsSettingServers.md
@@ -0,0 +1,30 @@
+# ServiceSettingsServicesDnsSettingServers
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**primary** | **str** | | [optional]
+**secondary** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_dns_setting_servers import ServiceSettingsServicesDnsSettingServers
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesDnsSettingServers from a JSON string
+service_settings_services_dns_setting_servers_instance = ServiceSettingsServicesDnsSettingServers.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesDnsSettingServers.to_json())
+
+# convert the object into a dict
+service_settings_services_dns_setting_servers_dict = service_settings_services_dns_setting_servers_instance.to_dict()
+# create an instance of ServiceSettingsServicesDnsSettingServers from a dict
+service_settings_services_dns_setting_servers_from_dict = ServiceSettingsServicesDnsSettingServers.from_dict(service_settings_services_dns_setting_servers_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesNtpServers.md b/scm/device_settings/docs/ServiceSettingsServicesNtpServers.md
new file mode 100644
index 00000000..1bcaf3fe
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesNtpServers.md
@@ -0,0 +1,30 @@
+# ServiceSettingsServicesNtpServers
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**primary_ntp_server** | [**ServiceSettingsServicesNtpServersPrimaryNtpServer**](ServiceSettingsServicesNtpServersPrimaryNtpServer.md) | | [optional]
+**secondary_ntp_server** | [**ServiceSettingsServicesNtpServersPrimaryNtpServer**](ServiceSettingsServicesNtpServersPrimaryNtpServer.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_ntp_servers import ServiceSettingsServicesNtpServers
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesNtpServers from a JSON string
+service_settings_services_ntp_servers_instance = ServiceSettingsServicesNtpServers.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesNtpServers.to_json())
+
+# convert the object into a dict
+service_settings_services_ntp_servers_dict = service_settings_services_ntp_servers_instance.to_dict()
+# create an instance of ServiceSettingsServicesNtpServers from a dict
+service_settings_services_ntp_servers_from_dict = ServiceSettingsServicesNtpServers.from_dict(service_settings_services_ntp_servers_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServer.md b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServer.md
new file mode 100644
index 00000000..3d591db4
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServer.md
@@ -0,0 +1,30 @@
+# ServiceSettingsServicesNtpServersPrimaryNtpServer
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authentication_type** | [**ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType**](ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.md) | | [optional]
+**ntp_server_address** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server import ServiceSettingsServicesNtpServersPrimaryNtpServer
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServer from a JSON string
+service_settings_services_ntp_servers_primary_ntp_server_instance = ServiceSettingsServicesNtpServersPrimaryNtpServer.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesNtpServersPrimaryNtpServer.to_json())
+
+# convert the object into a dict
+service_settings_services_ntp_servers_primary_ntp_server_dict = service_settings_services_ntp_servers_primary_ntp_server_instance.to_dict()
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServer from a dict
+service_settings_services_ntp_servers_primary_ntp_server_from_dict = ServiceSettingsServicesNtpServersPrimaryNtpServer.from_dict(service_settings_services_ntp_servers_primary_ntp_server_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.md b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.md
new file mode 100644
index 00000000..cca8040c
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.md
@@ -0,0 +1,31 @@
+# ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**autokey** | **object** | | [optional]
+**var_none** | **object** | | [optional]
+**symmetric_key** | [**ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey**](ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType from a JSON string
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_instance = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.to_json())
+
+# convert the object into a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_dict = service_settings_services_ntp_servers_primary_ntp_server_authentication_type_instance.to_dict()
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType from a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_from_dict = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.from_dict(service_settings_services_ntp_servers_primary_ntp_server_authentication_type_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.md b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.md
new file mode 100644
index 00000000..91865d48
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.md
@@ -0,0 +1,30 @@
+# ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**algorithm** | [**ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm**](ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.md) | | [optional]
+**key_id** | **float** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey from a JSON string
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_instance = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.to_json())
+
+# convert the object into a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_dict = service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_instance.to_dict()
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey from a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_from_dict = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.from_dict(service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.md b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.md
new file mode 100644
index 00000000..e175c305
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.md
@@ -0,0 +1,30 @@
+# ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**md5** | [**ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5**](ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.md) | | [optional]
+**sha1** | [**ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5**](ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm from a JSON string
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_instance = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.to_json())
+
+# convert the object into a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_dict = service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_instance.to_dict()
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm from a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_from_dict = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.from_dict(service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.md b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.md
new file mode 100644
index 00000000..c01a67ef
--- /dev/null
+++ b/scm/device_settings/docs/ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.md
@@ -0,0 +1,29 @@
+# ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authentication_key** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5 import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5 from a JSON string
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5_instance = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.from_json(json)
+# print the JSON string representation of the object
+print(ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.to_json())
+
+# convert the object into a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5_dict = service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5_instance.to_dict()
+# create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5 from a dict
+service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5_from_dict = ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.from_dict(service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionSettings.md b/scm/device_settings/docs/SessionSettings.md
new file mode 100644
index 00000000..0920ae34
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettings.md
@@ -0,0 +1,33 @@
+# SessionSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**session_settings** | [**SessionSettingsSessionSettings**](SessionSettingsSessionSettings.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.session_settings import SessionSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionSettings from a JSON string
+session_settings_instance = SessionSettings.from_json(json)
+# print the JSON string representation of the object
+print(SessionSettings.to_json())
+
+# convert the object into a dict
+session_settings_dict = session_settings_instance.to_dict()
+# create an instance of SessionSettings from a dict
+session_settings_from_dict = SessionSettings.from_dict(session_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionSettingsApi.md b/scm/device_settings/docs/SessionSettingsApi.md
new file mode 100644
index 00000000..0f8de019
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.SessionSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_session_settings**](SessionSettingsApi.md#create_session_settings) | **POST** /session-settings | Create session settings
+[**delete_session_settings_by_id**](SessionSettingsApi.md#delete_session_settings_by_id) | **DELETE** /session-settings/{id} | Delete session settings
+[**get_session_settings_by_id**](SessionSettingsApi.md#get_session_settings_by_id) | **GET** /session-settings/{id} | Get existing session settings
+[**list_session_settings**](SessionSettingsApi.md#list_session_settings) | **GET** /session-settings | List session settings
+[**update_session_settings_by_id**](SessionSettingsApi.md#update_session_settings_by_id) | **PUT** /session-settings/{id} | Update session settings
+
+
+# **create_session_settings**
+> SessionSettings create_session_settings(session_settings=session_settings)
+
+Create session settings
+
+Create new session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_settings import SessionSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionSettingsApi(api_client)
+ session_settings = scm.device_settings.SessionSettings() # SessionSettings | (optional)
+
+ try:
+ # Create session settings
+ api_response = api_instance.create_session_settings(session_settings=session_settings)
+ print("The response of SessionSettingsApi->create_session_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionSettingsApi->create_session_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **session_settings** | [**SessionSettings**](SessionSettings.md)| | [optional]
+
+### Return type
+
+[**SessionSettings**](SessionSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_session_settings_by_id**
+> delete_session_settings_by_id(id)
+
+Delete session settings
+
+Delete the session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete session settings
+ api_instance.delete_session_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling SessionSettingsApi->delete_session_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_session_settings_by_id**
+> SessionSettings get_session_settings_by_id(id)
+
+Get existing session settings
+
+Retrieve existing session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_settings import SessionSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing session settings
+ api_response = api_instance.get_session_settings_by_id(id)
+ print("The response of SessionSettingsApi->get_session_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionSettingsApi->get_session_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**SessionSettings**](SessionSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_session_settings**
+> List[SessionSettings] list_session_settings(folder=folder, snippet=snippet, device=device)
+
+List session settings
+
+Retrieve a list of session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_settings import SessionSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List session settings
+ api_response = api_instance.list_session_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of SessionSettingsApi->list_session_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionSettingsApi->list_session_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[SessionSettings]**](SessionSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_session_settings_by_id**
+> SessionSettings update_session_settings_by_id(id, session_settings=session_settings)
+
+Update session settings
+
+Update the session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_settings import SessionSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ session_settings = scm.device_settings.SessionSettings() # SessionSettings | OK (optional)
+
+ try:
+ # Update session settings
+ api_response = api_instance.update_session_settings_by_id(id, session_settings=session_settings)
+ print("The response of SessionSettingsApi->update_session_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionSettingsApi->update_session_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **session_settings** | [**SessionSettings**](SessionSettings.md)| OK | [optional]
+
+### Return type
+
+[**SessionSettings**](SessionSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/SessionSettingsSessionSettings.md b/scm/device_settings/docs/SessionSettingsSessionSettings.md
new file mode 100644
index 00000000..de304e95
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettingsSessionSettings.md
@@ -0,0 +1,54 @@
+# SessionSettingsSessionSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**accelerated_aging_enable** | **bool** | Enable accelerated aging | [optional] [default to True]
+**accelerated_aging_scaling_factor** | **float** | Accelerated aging scaling factor | [optional] [default to 2]
+**accelerated_aging_threshold** | **float** | Accelerated aging threshold | [optional] [default to 80]
+**config** | [**SessionSettingsSessionSettingsConfig**](SessionSettingsSessionSettingsConfig.md) | | [optional]
+**dhcp_bcast_session_on** | **bool** | Enable DHCP broadcast session | [optional] [default to False]
+**erspan** | **bool** | Enable ERSPAN support | [optional] [default to False]
+**icmp_unreachable_rate** | **float** | ICMP unreachable packet rate (per second) | [optional] [default to 200]
+**icmpv6_rate_limit** | [**SessionSettingsSessionSettingsIcmpv6RateLimit**](SessionSettingsSessionSettingsIcmpv6RateLimit.md) | | [optional]
+**ipv6_firewalling** | **bool** | Enable IPv6 firewalling | [optional] [default to True]
+**jumbo_frame** | [**SessionSettingsSessionSettingsJumboFrame**](SessionSettingsSessionSettingsJumboFrame.md) | | [optional]
+**max_pending_mcast_pkts_per_session** | **float** | Multicast route setup buffer size | [optional] [default to 1000]
+**multicast_route_setup_buffering** | **bool** | Multicast route setup buffering | [optional] [default to False]
+**nat** | [**SessionSettingsSessionSettingsNat**](SessionSettingsSessionSettingsNat.md) | | [optional]
+**nat64** | [**SessionSettingsSessionSettingsNat64**](SessionSettingsSessionSettingsNat64.md) | | [optional]
+**packet_buffer_protection_activate** | **float** | Activate (%) | [optional] [default to 80]
+**packet_buffer_protection_alert** | **int** | Alert (%) | [optional] [default to 50]
+**packet_buffer_protection_block_countdown** | **float** | Block countdown threshold (%) | [optional] [default to 80]
+**packet_buffer_protection_block_duration_time** | **float** | Block duration (seconds) | [optional] [default to 3600]
+**packet_buffer_protection_block_hold_time** | **float** | Block hold time (seconds) | [optional] [default to 60]
+**packet_buffer_protection_enable** | **bool** | Enable packet buffer protection | [optional] [default to True]
+**packet_buffer_protection_latency_activate** | **float** | Latency activate (milliseconds) | [optional] [default to 200]
+**packet_buffer_protection_latency_alert** | **float** | Latency alert (milliseconds) | [optional] [default to 50]
+**packet_buffer_protection_latency_block_countdown** | **float** | Block countdown threshold (milliseconds) | [optional] [default to 500]
+**packet_buffer_protection_latency_max_tolerate** | **float** | Latency max tolerate (milliseconds) | [optional] [default to 500]
+**packet_buffer_protection_monitor_only** | **bool** | Packet buffer protection monitor only | [optional] [default to False]
+**packet_buffer_protection_use_latency** | **bool** | Enabled latency-based activation | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.session_settings_session_settings import SessionSettingsSessionSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionSettingsSessionSettings from a JSON string
+session_settings_session_settings_instance = SessionSettingsSessionSettings.from_json(json)
+# print the JSON string representation of the object
+print(SessionSettingsSessionSettings.to_json())
+
+# convert the object into a dict
+session_settings_session_settings_dict = session_settings_session_settings_instance.to_dict()
+# create an instance of SessionSettingsSessionSettings from a dict
+session_settings_session_settings_from_dict = SessionSettingsSessionSettings.from_dict(session_settings_session_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionSettingsSessionSettingsConfig.md b/scm/device_settings/docs/SessionSettingsSessionSettingsConfig.md
new file mode 100644
index 00000000..0fcf7b0f
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettingsSessionSettingsConfig.md
@@ -0,0 +1,29 @@
+# SessionSettingsSessionSettingsConfig
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**rematch** | **bool** | Rematch all sessions on config policy change | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.session_settings_session_settings_config import SessionSettingsSessionSettingsConfig
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionSettingsSessionSettingsConfig from a JSON string
+session_settings_session_settings_config_instance = SessionSettingsSessionSettingsConfig.from_json(json)
+# print the JSON string representation of the object
+print(SessionSettingsSessionSettingsConfig.to_json())
+
+# convert the object into a dict
+session_settings_session_settings_config_dict = session_settings_session_settings_config_instance.to_dict()
+# create an instance of SessionSettingsSessionSettingsConfig from a dict
+session_settings_session_settings_config_from_dict = SessionSettingsSessionSettingsConfig.from_dict(session_settings_session_settings_config_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionSettingsSessionSettingsIcmpv6RateLimit.md b/scm/device_settings/docs/SessionSettingsSessionSettingsIcmpv6RateLimit.md
new file mode 100644
index 00000000..e403f38d
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettingsSessionSettingsIcmpv6RateLimit.md
@@ -0,0 +1,31 @@
+# SessionSettingsSessionSettingsIcmpv6RateLimit
+
+ICMPv6 rate limiting
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**bucket_size** | **int** | ICMPv6 token bucket size | [optional] [default to 100]
+**packet_rate** | **int** | ICMPv6 error packet pate (per second) | [optional] [default to 100]
+
+## Example
+
+```python
+from scm.device_settings.models.session_settings_session_settings_icmpv6_rate_limit import SessionSettingsSessionSettingsIcmpv6RateLimit
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionSettingsSessionSettingsIcmpv6RateLimit from a JSON string
+session_settings_session_settings_icmpv6_rate_limit_instance = SessionSettingsSessionSettingsIcmpv6RateLimit.from_json(json)
+# print the JSON string representation of the object
+print(SessionSettingsSessionSettingsIcmpv6RateLimit.to_json())
+
+# convert the object into a dict
+session_settings_session_settings_icmpv6_rate_limit_dict = session_settings_session_settings_icmpv6_rate_limit_instance.to_dict()
+# create an instance of SessionSettingsSessionSettingsIcmpv6RateLimit from a dict
+session_settings_session_settings_icmpv6_rate_limit_from_dict = SessionSettingsSessionSettingsIcmpv6RateLimit.from_dict(session_settings_session_settings_icmpv6_rate_limit_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionSettingsSessionSettingsJumboFrame.md b/scm/device_settings/docs/SessionSettingsSessionSettingsJumboFrame.md
new file mode 100644
index 00000000..b4374c94
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettingsSessionSettingsJumboFrame.md
@@ -0,0 +1,30 @@
+# SessionSettingsSessionSettingsJumboFrame
+
+Enable jumbo frame support
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**mtu** | **int** | Global MTU | [optional] [default to 9192]
+
+## Example
+
+```python
+from scm.device_settings.models.session_settings_session_settings_jumbo_frame import SessionSettingsSessionSettingsJumboFrame
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionSettingsSessionSettingsJumboFrame from a JSON string
+session_settings_session_settings_jumbo_frame_instance = SessionSettingsSessionSettingsJumboFrame.from_json(json)
+# print the JSON string representation of the object
+print(SessionSettingsSessionSettingsJumboFrame.to_json())
+
+# convert the object into a dict
+session_settings_session_settings_jumbo_frame_dict = session_settings_session_settings_jumbo_frame_instance.to_dict()
+# create an instance of SessionSettingsSessionSettingsJumboFrame from a dict
+session_settings_session_settings_jumbo_frame_from_dict = SessionSettingsSessionSettingsJumboFrame.from_dict(session_settings_session_settings_jumbo_frame_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionSettingsSessionSettingsNat.md b/scm/device_settings/docs/SessionSettingsSessionSettingsNat.md
new file mode 100644
index 00000000..59e3f721
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettingsSessionSettingsNat.md
@@ -0,0 +1,29 @@
+# SessionSettingsSessionSettingsNat
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**dipp_oversub** | **str** | NAT oversubscription rate | [optional] [default to '1x']
+
+## Example
+
+```python
+from scm.device_settings.models.session_settings_session_settings_nat import SessionSettingsSessionSettingsNat
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionSettingsSessionSettingsNat from a JSON string
+session_settings_session_settings_nat_instance = SessionSettingsSessionSettingsNat.from_json(json)
+# print the JSON string representation of the object
+print(SessionSettingsSessionSettingsNat.to_json())
+
+# convert the object into a dict
+session_settings_session_settings_nat_dict = session_settings_session_settings_nat_instance.to_dict()
+# create an instance of SessionSettingsSessionSettingsNat from a dict
+session_settings_session_settings_nat_from_dict = SessionSettingsSessionSettingsNat.from_dict(session_settings_session_settings_nat_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionSettingsSessionSettingsNat64.md b/scm/device_settings/docs/SessionSettingsSessionSettingsNat64.md
new file mode 100644
index 00000000..ca6e30b5
--- /dev/null
+++ b/scm/device_settings/docs/SessionSettingsSessionSettingsNat64.md
@@ -0,0 +1,29 @@
+# SessionSettingsSessionSettingsNat64
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ipv6_min_network_mtu** | **int** | NAT64 IPv6 minimum network MTU | [optional] [default to 1280]
+
+## Example
+
+```python
+from scm.device_settings.models.session_settings_session_settings_nat64 import SessionSettingsSessionSettingsNat64
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionSettingsSessionSettingsNat64 from a JSON string
+session_settings_session_settings_nat64_instance = SessionSettingsSessionSettingsNat64.from_json(json)
+# print the JSON string representation of the object
+print(SessionSettingsSessionSettingsNat64.to_json())
+
+# convert the object into a dict
+session_settings_session_settings_nat64_dict = session_settings_session_settings_nat64_instance.to_dict()
+# create an instance of SessionSettingsSessionSettingsNat64 from a dict
+session_settings_session_settings_nat64_from_dict = SessionSettingsSessionSettingsNat64.from_dict(session_settings_session_settings_nat64_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionTimeouts.md b/scm/device_settings/docs/SessionTimeouts.md
new file mode 100644
index 00000000..45d303d6
--- /dev/null
+++ b/scm/device_settings/docs/SessionTimeouts.md
@@ -0,0 +1,33 @@
+# SessionTimeouts
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**session_timeouts** | [**SessionTimeoutsSessionTimeouts**](SessionTimeoutsSessionTimeouts.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionTimeouts from a JSON string
+session_timeouts_instance = SessionTimeouts.from_json(json)
+# print the JSON string representation of the object
+print(SessionTimeouts.to_json())
+
+# convert the object into a dict
+session_timeouts_dict = session_timeouts_instance.to_dict()
+# create an instance of SessionTimeouts from a dict
+session_timeouts_from_dict = SessionTimeouts.from_dict(session_timeouts_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionTimeoutsSessionTimeouts.md b/scm/device_settings/docs/SessionTimeoutsSessionTimeouts.md
new file mode 100644
index 00000000..36804c0c
--- /dev/null
+++ b/scm/device_settings/docs/SessionTimeoutsSessionTimeouts.md
@@ -0,0 +1,42 @@
+# SessionTimeoutsSessionTimeouts
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**timeout_captive_portal** | **int** | Captive Portal (seconds) | [optional] [default to 30]
+**timeout_default** | **int** | Default timeout (seconds) | [optional] [default to 30]
+**timeout_discard_default** | **int** | Discard default (seconds) | [optional] [default to 60]
+**timeout_discard_tcp** | **int** | Discard TCP (seconds) | [optional] [default to 90]
+**timeout_discard_udp** | **int** | Discard UDP (seconds) | [optional] [default to 60]
+**timeout_icmp** | **int** | ICMP (seconds) | [optional] [default to 6]
+**timeout_scan** | **int** | Scan (seconds) | [optional] [default to 10]
+**timeout_tcp** | **int** | TCP (seconds) | [optional] [default to 3600]
+**timeout_tcp_half_closed** | **int** | TCP Half Closed (seconds) | [optional] [default to 120]
+**timeout_tcp_time_wait** | **int** | TCP Time Wait (seconds) | [optional] [default to 15]
+**timeout_tcp_unverified_rst** | **int** | Unverified RST (seconds) | [optional] [default to 30]
+**timeout_tcphandshake** | **int** | TCP handshake (seconds) | [optional] [default to 10]
+**timeout_tcpinit** | **int** | TCP init (seconds) | [optional] [default to 5]
+**timeout_udp** | **int** | UDP (seconds) | [optional] [default to 30]
+
+## Example
+
+```python
+from scm.device_settings.models.session_timeouts_session_timeouts import SessionTimeoutsSessionTimeouts
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SessionTimeoutsSessionTimeouts from a JSON string
+session_timeouts_session_timeouts_instance = SessionTimeoutsSessionTimeouts.from_json(json)
+# print the JSON string representation of the object
+print(SessionTimeoutsSessionTimeouts.to_json())
+
+# convert the object into a dict
+session_timeouts_session_timeouts_dict = session_timeouts_session_timeouts_instance.to_dict()
+# create an instance of SessionTimeoutsSessionTimeouts from a dict
+session_timeouts_session_timeouts_from_dict = SessionTimeoutsSessionTimeouts.from_dict(session_timeouts_session_timeouts_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/SessionTimeoutsSettingsApi.md b/scm/device_settings/docs/SessionTimeoutsSettingsApi.md
new file mode 100644
index 00000000..c4793c7c
--- /dev/null
+++ b/scm/device_settings/docs/SessionTimeoutsSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.SessionTimeoutsSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_session_timeouts_settings**](SessionTimeoutsSettingsApi.md#create_session_timeouts_settings) | **POST** /session-timeouts | Create session timeouts settings
+[**delete_session_timeouts_settings_by_id**](SessionTimeoutsSettingsApi.md#delete_session_timeouts_settings_by_id) | **DELETE** /session-timeouts/{id} | Delete session settings
+[**get_session_timeouts_settings_by_id**](SessionTimeoutsSettingsApi.md#get_session_timeouts_settings_by_id) | **GET** /session-timeouts/{id} | Get existing session settings
+[**list_session_timeouts_settings**](SessionTimeoutsSettingsApi.md#list_session_timeouts_settings) | **GET** /session-timeouts | List session timeouts settings
+[**update_session_timeouts_settings_by_id**](SessionTimeoutsSettingsApi.md#update_session_timeouts_settings_by_id) | **PUT** /session-timeouts/{id} | Update session settings
+
+
+# **create_session_timeouts_settings**
+> SessionTimeouts create_session_timeouts_settings(session_timeouts=session_timeouts)
+
+Create session timeouts settings
+
+Create new session timeouts settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionTimeoutsSettingsApi(api_client)
+ session_timeouts = scm.device_settings.SessionTimeouts() # SessionTimeouts | (optional)
+
+ try:
+ # Create session timeouts settings
+ api_response = api_instance.create_session_timeouts_settings(session_timeouts=session_timeouts)
+ print("The response of SessionTimeoutsSettingsApi->create_session_timeouts_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionTimeoutsSettingsApi->create_session_timeouts_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **session_timeouts** | [**SessionTimeouts**](SessionTimeouts.md)| | [optional]
+
+### Return type
+
+[**SessionTimeouts**](SessionTimeouts.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_session_timeouts_settings_by_id**
+> delete_session_timeouts_settings_by_id(id)
+
+Delete session settings
+
+Delete the session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionTimeoutsSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete session settings
+ api_instance.delete_session_timeouts_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling SessionTimeoutsSettingsApi->delete_session_timeouts_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_session_timeouts_settings_by_id**
+> SessionTimeouts get_session_timeouts_settings_by_id(id)
+
+Get existing session settings
+
+Retrieve existing session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionTimeoutsSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing session settings
+ api_response = api_instance.get_session_timeouts_settings_by_id(id)
+ print("The response of SessionTimeoutsSettingsApi->get_session_timeouts_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionTimeoutsSettingsApi->get_session_timeouts_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**SessionTimeouts**](SessionTimeouts.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_session_timeouts_settings**
+> List[SessionTimeouts] list_session_timeouts_settings(folder=folder, snippet=snippet, device=device)
+
+List session timeouts settings
+
+Retrieve a list of session timeouts settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionTimeoutsSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List session timeouts settings
+ api_response = api_instance.list_session_timeouts_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of SessionTimeoutsSettingsApi->list_session_timeouts_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionTimeoutsSettingsApi->list_session_timeouts_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[SessionTimeouts]**](SessionTimeouts.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_session_timeouts_settings_by_id**
+> SessionTimeouts update_session_timeouts_settings_by_id(id, session_timeouts=session_timeouts)
+
+Update session settings
+
+Update the session settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.SessionTimeoutsSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ session_timeouts = scm.device_settings.SessionTimeouts() # SessionTimeouts | OK (optional)
+
+ try:
+ # Update session settings
+ api_response = api_instance.update_session_timeouts_settings_by_id(id, session_timeouts=session_timeouts)
+ print("The response of SessionTimeoutsSettingsApi->update_session_timeouts_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SessionTimeoutsSettingsApi->update_session_timeouts_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **session_timeouts** | [**SessionTimeouts**](SessionTimeouts.md)| OK | [optional]
+
+### Return type
+
+[**SessionTimeouts**](SessionTimeouts.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/TCPSettingsApi.md b/scm/device_settings/docs/TCPSettingsApi.md
new file mode 100644
index 00000000..edcc93f5
--- /dev/null
+++ b/scm/device_settings/docs/TCPSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.TCPSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_tcp_settings**](TCPSettingsApi.md#create_tcp_settings) | **POST** /tcp-settings | Create TCP settings
+[**delete_tcp_settings_by_id**](TCPSettingsApi.md#delete_tcp_settings_by_id) | **DELETE** /tcp-settings/{id} | Delete TCP settings
+[**get_tcp_settings_by_id**](TCPSettingsApi.md#get_tcp_settings_by_id) | **GET** /tcp-settings/{id} | Get existing TCP settings
+[**list_tcp_settings**](TCPSettingsApi.md#list_tcp_settings) | **GET** /tcp-settings | List TCP settings
+[**update_tcp_settings_by_id**](TCPSettingsApi.md#update_tcp_settings_by_id) | **PUT** /tcp-settings/{id} | Update TCP settings
+
+
+# **create_tcp_settings**
+> TcpSettings create_tcp_settings(tcp_settings=tcp_settings)
+
+Create TCP settings
+
+Create new TCP settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.tcp_settings import TcpSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.TCPSettingsApi(api_client)
+ tcp_settings = scm.device_settings.TcpSettings() # TcpSettings | (optional)
+
+ try:
+ # Create TCP settings
+ api_response = api_instance.create_tcp_settings(tcp_settings=tcp_settings)
+ print("The response of TCPSettingsApi->create_tcp_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TCPSettingsApi->create_tcp_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **tcp_settings** | [**TcpSettings**](TcpSettings.md)| | [optional]
+
+### Return type
+
+[**TcpSettings**](TcpSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_tcp_settings_by_id**
+> delete_tcp_settings_by_id(id)
+
+Delete TCP settings
+
+Delete the TCP settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.TCPSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete TCP settings
+ api_instance.delete_tcp_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling TCPSettingsApi->delete_tcp_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_tcp_settings_by_id**
+> TcpSettings get_tcp_settings_by_id(id)
+
+Get existing TCP settings
+
+Retrieve existing TCP settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.tcp_settings import TcpSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.TCPSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing TCP settings
+ api_response = api_instance.get_tcp_settings_by_id(id)
+ print("The response of TCPSettingsApi->get_tcp_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TCPSettingsApi->get_tcp_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**TcpSettings**](TcpSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_tcp_settings**
+> List[TcpSettings] list_tcp_settings(folder=folder, snippet=snippet, device=device)
+
+List TCP settings
+
+Retrieve a list of TCP settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.tcp_settings import TcpSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.TCPSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List TCP settings
+ api_response = api_instance.list_tcp_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of TCPSettingsApi->list_tcp_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TCPSettingsApi->list_tcp_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[TcpSettings]**](TcpSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_tcp_settings_by_id**
+> TcpSettings update_tcp_settings_by_id(id, tcp_settings=tcp_settings)
+
+Update TCP settings
+
+Update the TCP settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.tcp_settings import TcpSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.TCPSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ tcp_settings = scm.device_settings.TcpSettings() # TcpSettings | OK (optional)
+
+ try:
+ # Update TCP settings
+ api_response = api_instance.update_tcp_settings_by_id(id, tcp_settings=tcp_settings)
+ print("The response of TCPSettingsApi->update_tcp_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TCPSettingsApi->update_tcp_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **tcp_settings** | [**TcpSettings**](TcpSettings.md)| OK | [optional]
+
+### Return type
+
+[**TcpSettings**](TcpSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/TcpSettings.md b/scm/device_settings/docs/TcpSettings.md
new file mode 100644
index 00000000..2646631e
--- /dev/null
+++ b/scm/device_settings/docs/TcpSettings.md
@@ -0,0 +1,33 @@
+# TcpSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**tcp** | [**TcpSettingsTcp**](TcpSettingsTcp.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.tcp_settings import TcpSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TcpSettings from a JSON string
+tcp_settings_instance = TcpSettings.from_json(json)
+# print the JSON string representation of the object
+print(TcpSettings.to_json())
+
+# convert the object into a dict
+tcp_settings_dict = tcp_settings_instance.to_dict()
+# create an instance of TcpSettings from a dict
+tcp_settings_from_dict = TcpSettings.from_dict(tcp_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/TcpSettingsTcp.md b/scm/device_settings/docs/TcpSettingsTcp.md
new file mode 100644
index 00000000..7d2a285e
--- /dev/null
+++ b/scm/device_settings/docs/TcpSettingsTcp.md
@@ -0,0 +1,37 @@
+# TcpSettingsTcp
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**allow_challenge_ack** | **bool** | Allow arbitrary ACK in response to SYN? | [optional]
+**asymmetric_path** | **str** | Asymmetric path action | [optional]
+**bypass_exceed_oo_queue** | **bool** | Forward segments exceeding TCP out-of-order queue? | [optional]
+**check_timestamp_option** | **bool** | Drop segments with null timestamp option? | [optional]
+**drop_zero_flag** | **bool** | Drop segments without flag? | [optional]
+**siptcp_cleartext_proxy** | **str** | SIP TCP cleartext action (`'0'` = Always Off, `'1'` = Always Enabled, `'2'` = Automatically enable proxy when needed) | [optional]
+**strip_mptcp_option** | **bool** | Strip MPTCP option? | [optional]
+**tcp_retransmit_scan** | **bool** | TCP retransmit scan? | [optional]
+**urgent_data** | **str** | Urgent data flag action | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.tcp_settings_tcp import TcpSettingsTcp
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TcpSettingsTcp from a JSON string
+tcp_settings_tcp_instance = TcpSettingsTcp.from_json(json)
+# print the JSON string representation of the object
+print(TcpSettingsTcp.to_json())
+
+# convert the object into a dict
+tcp_settings_tcp_dict = tcp_settings_tcp_instance.to_dict()
+# create an instance of TcpSettingsTcp from a dict
+tcp_settings_tcp_from_dict = TcpSettingsTcp.from_dict(tcp_settings_tcp_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateSchedule.md b/scm/device_settings/docs/UpdateSchedule.md
new file mode 100644
index 00000000..8f656d3b
--- /dev/null
+++ b/scm/device_settings/docs/UpdateSchedule.md
@@ -0,0 +1,33 @@
+# UpdateSchedule
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**update_schedule** | [**UpdateScheduleUpdateSchedule**](UpdateScheduleUpdateSchedule.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule import UpdateSchedule
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateSchedule from a JSON string
+update_schedule_instance = UpdateSchedule.from_json(json)
+# print the JSON string representation of the object
+print(UpdateSchedule.to_json())
+
+# convert the object into a dict
+update_schedule_dict = update_schedule_instance.to_dict()
+# create an instance of UpdateSchedule from a dict
+update_schedule_from_dict = UpdateSchedule.from_dict(update_schedule_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleSettingsApi.md b/scm/device_settings/docs/UpdateScheduleSettingsApi.md
new file mode 100644
index 00000000..6e587493
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.UpdateScheduleSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_update_schedule_settings**](UpdateScheduleSettingsApi.md#create_update_schedule_settings) | **POST** /update-schedule | Create update schedule settings
+[**delete_update_schedule_settings_by_id**](UpdateScheduleSettingsApi.md#delete_update_schedule_settings_by_id) | **DELETE** /update-schedule/{id} | Delete update schedule settings
+[**get_update_schedule_settings_by_id**](UpdateScheduleSettingsApi.md#get_update_schedule_settings_by_id) | **GET** /update-schedule/{id} | Get existing update schedule settings
+[**list_update_schedule_settings**](UpdateScheduleSettingsApi.md#list_update_schedule_settings) | **GET** /update-schedule | List update schedule settings
+[**update_update_schedule_settings_by_id**](UpdateScheduleSettingsApi.md#update_update_schedule_settings_by_id) | **PUT** /update-schedule/{id} | Update update schedule settings
+
+
+# **create_update_schedule_settings**
+> UpdateSchedule create_update_schedule_settings(update_schedule=update_schedule)
+
+Create update schedule settings
+
+Create new update schedule settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.update_schedule import UpdateSchedule
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.UpdateScheduleSettingsApi(api_client)
+ update_schedule = scm.device_settings.UpdateSchedule() # UpdateSchedule | (optional)
+
+ try:
+ # Create update schedule settings
+ api_response = api_instance.create_update_schedule_settings(update_schedule=update_schedule)
+ print("The response of UpdateScheduleSettingsApi->create_update_schedule_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling UpdateScheduleSettingsApi->create_update_schedule_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **update_schedule** | [**UpdateSchedule**](UpdateSchedule.md)| | [optional]
+
+### Return type
+
+[**UpdateSchedule**](UpdateSchedule.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_update_schedule_settings_by_id**
+> delete_update_schedule_settings_by_id(id)
+
+Delete update schedule settings
+
+Delete the update schedule settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.UpdateScheduleSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete update schedule settings
+ api_instance.delete_update_schedule_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling UpdateScheduleSettingsApi->delete_update_schedule_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_update_schedule_settings_by_id**
+> UpdateSchedule get_update_schedule_settings_by_id(id)
+
+Get existing update schedule settings
+
+Retrieve existing update schedule settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.update_schedule import UpdateSchedule
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.UpdateScheduleSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing update schedule settings
+ api_response = api_instance.get_update_schedule_settings_by_id(id)
+ print("The response of UpdateScheduleSettingsApi->get_update_schedule_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling UpdateScheduleSettingsApi->get_update_schedule_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**UpdateSchedule**](UpdateSchedule.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_update_schedule_settings**
+> List[UpdateSchedule] list_update_schedule_settings(folder=folder, snippet=snippet, device=device)
+
+List update schedule settings
+
+Retrieve a list of update schedule settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.update_schedule import UpdateSchedule
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.UpdateScheduleSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List update schedule settings
+ api_response = api_instance.list_update_schedule_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of UpdateScheduleSettingsApi->list_update_schedule_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling UpdateScheduleSettingsApi->list_update_schedule_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[UpdateSchedule]**](UpdateSchedule.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_update_schedule_settings_by_id**
+> UpdateSchedule update_update_schedule_settings_by_id(id, update_schedule=update_schedule)
+
+Update update schedule settings
+
+Update the update schedule settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.update_schedule import UpdateSchedule
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.UpdateScheduleSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ update_schedule = scm.device_settings.UpdateSchedule() # UpdateSchedule | OK (optional)
+
+ try:
+ # Update update schedule settings
+ api_response = api_instance.update_update_schedule_settings_by_id(id, update_schedule=update_schedule)
+ print("The response of UpdateScheduleSettingsApi->update_update_schedule_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling UpdateScheduleSettingsApi->update_update_schedule_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **update_schedule** | [**UpdateSchedule**](UpdateSchedule.md)| OK | [optional]
+
+### Return type
+
+[**UpdateSchedule**](UpdateSchedule.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateSchedule.md b/scm/device_settings/docs/UpdateScheduleUpdateSchedule.md
new file mode 100644
index 00000000..52a0cfc0
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateSchedule.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateSchedule
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**anti_virus** | [**UpdateScheduleUpdateScheduleAntiVirus**](UpdateScheduleUpdateScheduleAntiVirus.md) | |
+**threats** | [**UpdateScheduleUpdateScheduleThreats**](UpdateScheduleUpdateScheduleThreats.md) | |
+**wildfire** | [**UpdateScheduleUpdateScheduleWildfire**](UpdateScheduleUpdateScheduleWildfire.md) | |
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule import UpdateScheduleUpdateSchedule
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateSchedule from a JSON string
+update_schedule_update_schedule_instance = UpdateScheduleUpdateSchedule.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateSchedule.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_dict = update_schedule_update_schedule_instance.to_dict()
+# create an instance of UpdateScheduleUpdateSchedule from a dict
+update_schedule_update_schedule_from_dict = UpdateScheduleUpdateSchedule.from_dict(update_schedule_update_schedule_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirus.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirus.md
new file mode 100644
index 00000000..58a332c2
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirus.md
@@ -0,0 +1,29 @@
+# UpdateScheduleUpdateScheduleAntiVirus
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**recurring** | [**UpdateScheduleUpdateScheduleAntiVirusRecurring**](UpdateScheduleUpdateScheduleAntiVirusRecurring.md) | |
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus import UpdateScheduleUpdateScheduleAntiVirus
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleAntiVirus from a JSON string
+update_schedule_update_schedule_anti_virus_instance = UpdateScheduleUpdateScheduleAntiVirus.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleAntiVirus.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_anti_virus_dict = update_schedule_update_schedule_anti_virus_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleAntiVirus from a dict
+update_schedule_update_schedule_anti_virus_from_dict = UpdateScheduleUpdateScheduleAntiVirus.from_dict(update_schedule_update_schedule_anti_virus_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurring.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurring.md
new file mode 100644
index 00000000..7135f22c
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurring.md
@@ -0,0 +1,34 @@
+# UpdateScheduleUpdateScheduleAntiVirusRecurring
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**daily** | [**UpdateScheduleUpdateScheduleAntiVirusRecurringDaily**](UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.md) | | [optional]
+**hourly** | [**UpdateScheduleUpdateScheduleAntiVirusRecurringHourly**](UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.md) | | [optional]
+**var_none** | **object** | | [optional]
+**sync_to_peer** | **bool** | | [default to False]
+**threshold** | **int** | | [optional]
+**weekly** | [**UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly**](UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring import UpdateScheduleUpdateScheduleAntiVirusRecurring
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurring from a JSON string
+update_schedule_update_schedule_anti_virus_recurring_instance = UpdateScheduleUpdateScheduleAntiVirusRecurring.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleAntiVirusRecurring.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_anti_virus_recurring_dict = update_schedule_update_schedule_anti_virus_recurring_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurring from a dict
+update_schedule_update_schedule_anti_virus_recurring_from_dict = UpdateScheduleUpdateScheduleAntiVirusRecurring.from_dict(update_schedule_update_schedule_anti_virus_recurring_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.md
new file mode 100644
index 00000000..5578d5cd
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.md
@@ -0,0 +1,30 @@
+# UpdateScheduleUpdateScheduleAntiVirusRecurringDaily
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **str** | |
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_daily import UpdateScheduleUpdateScheduleAntiVirusRecurringDaily
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringDaily from a JSON string
+update_schedule_update_schedule_anti_virus_recurring_daily_instance = UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_anti_virus_recurring_daily_dict = update_schedule_update_schedule_anti_virus_recurring_daily_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringDaily from a dict
+update_schedule_update_schedule_anti_virus_recurring_daily_from_dict = UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.from_dict(update_schedule_update_schedule_anti_virus_recurring_daily_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.md
new file mode 100644
index 00000000..fbb15a66
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.md
@@ -0,0 +1,30 @@
+# UpdateScheduleUpdateScheduleAntiVirusRecurringHourly
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **int** | | [default to 0]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_hourly import UpdateScheduleUpdateScheduleAntiVirusRecurringHourly
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringHourly from a JSON string
+update_schedule_update_schedule_anti_virus_recurring_hourly_instance = UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_anti_virus_recurring_hourly_dict = update_schedule_update_schedule_anti_virus_recurring_hourly_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringHourly from a dict
+update_schedule_update_schedule_anti_virus_recurring_hourly_from_dict = UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.from_dict(update_schedule_update_schedule_anti_virus_recurring_hourly_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.md
new file mode 100644
index 00000000..8598023e
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **str** | | [optional]
+**day_of_week** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_weekly import UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly from a JSON string
+update_schedule_update_schedule_anti_virus_recurring_weekly_instance = UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_anti_virus_recurring_weekly_dict = update_schedule_update_schedule_anti_virus_recurring_weekly_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly from a dict
+update_schedule_update_schedule_anti_virus_recurring_weekly_from_dict = UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.from_dict(update_schedule_update_schedule_anti_virus_recurring_weekly_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreats.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreats.md
new file mode 100644
index 00000000..63ebe0e9
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreats.md
@@ -0,0 +1,29 @@
+# UpdateScheduleUpdateScheduleThreats
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**recurring** | [**UpdateScheduleUpdateScheduleThreatsRecurring**](UpdateScheduleUpdateScheduleThreatsRecurring.md) | |
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_threats import UpdateScheduleUpdateScheduleThreats
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleThreats from a JSON string
+update_schedule_update_schedule_threats_instance = UpdateScheduleUpdateScheduleThreats.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleThreats.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_threats_dict = update_schedule_update_schedule_threats_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleThreats from a dict
+update_schedule_update_schedule_threats_from_dict = UpdateScheduleUpdateScheduleThreats.from_dict(update_schedule_update_schedule_threats_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurring.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurring.md
new file mode 100644
index 00000000..341fc83e
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurring.md
@@ -0,0 +1,36 @@
+# UpdateScheduleUpdateScheduleThreatsRecurring
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**daily** | [**UpdateScheduleUpdateScheduleThreatsRecurringDaily**](UpdateScheduleUpdateScheduleThreatsRecurringDaily.md) | | [optional]
+**every_30_mins** | [**UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins**](UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.md) | | [optional]
+**hourly** | [**UpdateScheduleUpdateScheduleThreatsRecurringHourly**](UpdateScheduleUpdateScheduleThreatsRecurringHourly.md) | | [optional]
+**new_app_threshold** | **int** | | [optional]
+**var_none** | **object** | | [optional]
+**sync_to_peer** | **bool** | | [default to False]
+**threshold** | **int** | | [optional]
+**weekly** | [**UpdateScheduleUpdateScheduleThreatsRecurringWeekly**](UpdateScheduleUpdateScheduleThreatsRecurringWeekly.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring import UpdateScheduleUpdateScheduleThreatsRecurring
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurring from a JSON string
+update_schedule_update_schedule_threats_recurring_instance = UpdateScheduleUpdateScheduleThreatsRecurring.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleThreatsRecurring.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_threats_recurring_dict = update_schedule_update_schedule_threats_recurring_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurring from a dict
+update_schedule_update_schedule_threats_recurring_from_dict = UpdateScheduleUpdateScheduleThreatsRecurring.from_dict(update_schedule_update_schedule_threats_recurring_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringDaily.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringDaily.md
new file mode 100644
index 00000000..8fcec66f
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringDaily.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateScheduleThreatsRecurringDaily
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **str** | |
+**disable_new_content** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_daily import UpdateScheduleUpdateScheduleThreatsRecurringDaily
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringDaily from a JSON string
+update_schedule_update_schedule_threats_recurring_daily_instance = UpdateScheduleUpdateScheduleThreatsRecurringDaily.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleThreatsRecurringDaily.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_threats_recurring_daily_dict = update_schedule_update_schedule_threats_recurring_daily_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringDaily from a dict
+update_schedule_update_schedule_threats_recurring_daily_from_dict = UpdateScheduleUpdateScheduleThreatsRecurringDaily.from_dict(update_schedule_update_schedule_threats_recurring_daily_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.md
new file mode 100644
index 00000000..74d9a496
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **int** | | [optional] [default to 0]
+**disable_new_content** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_every30_mins import UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins from a JSON string
+update_schedule_update_schedule_threats_recurring_every30_mins_instance = UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_threats_recurring_every30_mins_dict = update_schedule_update_schedule_threats_recurring_every30_mins_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins from a dict
+update_schedule_update_schedule_threats_recurring_every30_mins_from_dict = UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.from_dict(update_schedule_update_schedule_threats_recurring_every30_mins_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringHourly.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringHourly.md
new file mode 100644
index 00000000..4942a4dd
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringHourly.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateScheduleThreatsRecurringHourly
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **float** | | [default to 0]
+**disable_new_content** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_hourly import UpdateScheduleUpdateScheduleThreatsRecurringHourly
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringHourly from a JSON string
+update_schedule_update_schedule_threats_recurring_hourly_instance = UpdateScheduleUpdateScheduleThreatsRecurringHourly.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleThreatsRecurringHourly.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_threats_recurring_hourly_dict = update_schedule_update_schedule_threats_recurring_hourly_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringHourly from a dict
+update_schedule_update_schedule_threats_recurring_hourly_from_dict = UpdateScheduleUpdateScheduleThreatsRecurringHourly.from_dict(update_schedule_update_schedule_threats_recurring_hourly_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringWeekly.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringWeekly.md
new file mode 100644
index 00000000..52190cce
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleThreatsRecurringWeekly.md
@@ -0,0 +1,32 @@
+# UpdateScheduleUpdateScheduleThreatsRecurringWeekly
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **str** | |
+**day_of_week** | **str** | |
+**disable_new_content** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_weekly import UpdateScheduleUpdateScheduleThreatsRecurringWeekly
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringWeekly from a JSON string
+update_schedule_update_schedule_threats_recurring_weekly_instance = UpdateScheduleUpdateScheduleThreatsRecurringWeekly.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleThreatsRecurringWeekly.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_threats_recurring_weekly_dict = update_schedule_update_schedule_threats_recurring_weekly_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleThreatsRecurringWeekly from a dict
+update_schedule_update_schedule_threats_recurring_weekly_from_dict = UpdateScheduleUpdateScheduleThreatsRecurringWeekly.from_dict(update_schedule_update_schedule_threats_recurring_weekly_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfire.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfire.md
new file mode 100644
index 00000000..49530ffb
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfire.md
@@ -0,0 +1,29 @@
+# UpdateScheduleUpdateScheduleWildfire
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**recurring** | [**UpdateScheduleUpdateScheduleWildfireRecurring**](UpdateScheduleUpdateScheduleWildfireRecurring.md) | |
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_wildfire import UpdateScheduleUpdateScheduleWildfire
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleWildfire from a JSON string
+update_schedule_update_schedule_wildfire_instance = UpdateScheduleUpdateScheduleWildfire.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleWildfire.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_wildfire_dict = update_schedule_update_schedule_wildfire_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleWildfire from a dict
+update_schedule_update_schedule_wildfire_from_dict = UpdateScheduleUpdateScheduleWildfire.from_dict(update_schedule_update_schedule_wildfire_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurring.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurring.md
new file mode 100644
index 00000000..9b228892
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurring.md
@@ -0,0 +1,34 @@
+# UpdateScheduleUpdateScheduleWildfireRecurring
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**every_15_mins** | [**UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins**](UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.md) | | [optional]
+**every_30_mins** | [**UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins**](UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.md) | | [optional]
+**every_hour** | [**UpdateScheduleUpdateScheduleWildfireRecurringEveryHour**](UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.md) | | [optional]
+**every_min** | [**UpdateScheduleUpdateScheduleWildfireRecurringEveryMin**](UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.md) | | [optional]
+**var_none** | **object** | | [optional]
+**real_time** | **object** | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring import UpdateScheduleUpdateScheduleWildfireRecurring
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurring from a JSON string
+update_schedule_update_schedule_wildfire_recurring_instance = UpdateScheduleUpdateScheduleWildfireRecurring.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleWildfireRecurring.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_wildfire_recurring_dict = update_schedule_update_schedule_wildfire_recurring_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurring from a dict
+update_schedule_update_schedule_wildfire_recurring_from_dict = UpdateScheduleUpdateScheduleWildfireRecurring.from_dict(update_schedule_update_schedule_wildfire_recurring_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.md
new file mode 100644
index 00000000..28efe8a5
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **int** | | [optional] [default to 0]
+**sync_to_peer** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every15_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins from a JSON string
+update_schedule_update_schedule_wildfire_recurring_every15_mins_instance = UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_wildfire_recurring_every15_mins_dict = update_schedule_update_schedule_wildfire_recurring_every15_mins_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins from a dict
+update_schedule_update_schedule_wildfire_recurring_every15_mins_from_dict = UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.from_dict(update_schedule_update_schedule_wildfire_recurring_every15_mins_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.md
new file mode 100644
index 00000000..bdd62ac8
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **int** | | [optional] [default to 0]
+**sync_to_peer** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every30_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins from a JSON string
+update_schedule_update_schedule_wildfire_recurring_every30_mins_instance = UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_wildfire_recurring_every30_mins_dict = update_schedule_update_schedule_wildfire_recurring_every30_mins_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins from a dict
+update_schedule_update_schedule_wildfire_recurring_every30_mins_from_dict = UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.from_dict(update_schedule_update_schedule_wildfire_recurring_every30_mins_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.md
new file mode 100644
index 00000000..8db3170f
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.md
@@ -0,0 +1,31 @@
+# UpdateScheduleUpdateScheduleWildfireRecurringEveryHour
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**at** | **int** | | [optional] [default to 0]
+**sync_to_peer** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_hour import UpdateScheduleUpdateScheduleWildfireRecurringEveryHour
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryHour from a JSON string
+update_schedule_update_schedule_wildfire_recurring_every_hour_instance = UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_wildfire_recurring_every_hour_dict = update_schedule_update_schedule_wildfire_recurring_every_hour_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryHour from a dict
+update_schedule_update_schedule_wildfire_recurring_every_hour_from_dict = UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.from_dict(update_schedule_update_schedule_wildfire_recurring_every_hour_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.md b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.md
new file mode 100644
index 00000000..e90056da
--- /dev/null
+++ b/scm/device_settings/docs/UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.md
@@ -0,0 +1,30 @@
+# UpdateScheduleUpdateScheduleWildfireRecurringEveryMin
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**action** | **str** | | [optional]
+**sync_to_peer** | **bool** | | [optional] [default to False]
+
+## Example
+
+```python
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_min import UpdateScheduleUpdateScheduleWildfireRecurringEveryMin
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryMin from a JSON string
+update_schedule_update_schedule_wildfire_recurring_every_min_instance = UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.from_json(json)
+# print the JSON string representation of the object
+print(UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.to_json())
+
+# convert the object into a dict
+update_schedule_update_schedule_wildfire_recurring_every_min_dict = update_schedule_update_schedule_wildfire_recurring_every_min_instance.to_dict()
+# create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryMin from a dict
+update_schedule_update_schedule_wildfire_recurring_every_min_from_dict = UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.from_dict(update_schedule_update_schedule_wildfire_recurring_every_min_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/VPNSettingsApi.md b/scm/device_settings/docs/VPNSettingsApi.md
new file mode 100644
index 00000000..54c731de
--- /dev/null
+++ b/scm/device_settings/docs/VPNSettingsApi.md
@@ -0,0 +1,434 @@
+# scm.device_settings.VPNSettingsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/device/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_vpn_settings**](VPNSettingsApi.md#create_vpn_settings) | **POST** /vpn-settings | Create VPN settings
+[**delete_vpn_settings_by_id**](VPNSettingsApi.md#delete_vpn_settings_by_id) | **DELETE** /vpn-settings/{id} | Delete VPN settings
+[**get_vpn_settings_by_id**](VPNSettingsApi.md#get_vpn_settings_by_id) | **GET** /vpn-settings/{id} | Get existing VPN settings
+[**list_vpn_settings**](VPNSettingsApi.md#list_vpn_settings) | **GET** /vpn-settings | List VPN settings
+[**update_vpn_settings_by_id**](VPNSettingsApi.md#update_vpn_settings_by_id) | **PUT** /vpn-settings/{id} | Update VPN settings
+
+
+# **create_vpn_settings**
+> VpnSettings create_vpn_settings(vpn_settings=vpn_settings)
+
+Create VPN settings
+
+Create new VPN settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.vpn_settings import VpnSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.VPNSettingsApi(api_client)
+ vpn_settings = scm.device_settings.VpnSettings() # VpnSettings | (optional)
+
+ try:
+ # Create VPN settings
+ api_response = api_instance.create_vpn_settings(vpn_settings=vpn_settings)
+ print("The response of VPNSettingsApi->create_vpn_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VPNSettingsApi->create_vpn_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **vpn_settings** | [**VpnSettings**](VpnSettings.md)| | [optional]
+
+### Return type
+
+[**VpnSettings**](VpnSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_vpn_settings_by_id**
+> delete_vpn_settings_by_id(id)
+
+Delete VPN settings
+
+Delete the VPN settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.VPNSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete VPN settings
+ api_instance.delete_vpn_settings_by_id(id)
+ except Exception as e:
+ print("Exception when calling VPNSettingsApi->delete_vpn_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_vpn_settings_by_id**
+> VpnSettings get_vpn_settings_by_id(id)
+
+Get existing VPN settings
+
+Retrieve existing VPN settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.vpn_settings import VpnSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.VPNSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get existing VPN settings
+ api_response = api_instance.get_vpn_settings_by_id(id)
+ print("The response of VPNSettingsApi->get_vpn_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VPNSettingsApi->get_vpn_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**VpnSettings**](VpnSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_vpn_settings**
+> List[VpnSettings] list_vpn_settings(folder=folder, snippet=snippet, device=device)
+
+List VPN settings
+
+Retrieve a list of VPN settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.vpn_settings import VpnSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.VPNSettingsApi(api_client)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+
+ try:
+ # List VPN settings
+ api_response = api_instance.list_vpn_settings(folder=folder, snippet=snippet, device=device)
+ print("The response of VPNSettingsApi->list_vpn_settings:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VPNSettingsApi->list_vpn_settings: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+
+### Return type
+
+[**List[VpnSettings]**](VpnSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_vpn_settings_by_id**
+> VpnSettings update_vpn_settings_by_id(id, vpn_settings=vpn_settings)
+
+Update VPN settings
+
+Update the VPN settings.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.device_settings
+from scm.device_settings.models.vpn_settings import VpnSettings
+from scm.device_settings.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/device/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.device_settings.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/device/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.device_settings.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.device_settings.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.device_settings.VPNSettingsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ vpn_settings = scm.device_settings.VpnSettings() # VpnSettings | OK (optional)
+
+ try:
+ # Update VPN settings
+ api_response = api_instance.update_vpn_settings_by_id(id, vpn_settings=vpn_settings)
+ print("The response of VPNSettingsApi->update_vpn_settings_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling VPNSettingsApi->update_vpn_settings_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **vpn_settings** | [**VpnSettings**](VpnSettings.md)| OK | [optional]
+
+### Return type
+
+[**VpnSettings**](VpnSettings.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/device_settings/docs/VpnSettings.md b/scm/device_settings/docs/VpnSettings.md
new file mode 100644
index 00000000..617bd171
--- /dev/null
+++ b/scm/device_settings/docs/VpnSettings.md
@@ -0,0 +1,33 @@
+# VpnSettings
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | UUID of the resource | [optional] [readonly]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**vpn** | [**VpnSettingsVpn**](VpnSettingsVpn.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.vpn_settings import VpnSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of VpnSettings from a JSON string
+vpn_settings_instance = VpnSettings.from_json(json)
+# print the JSON string representation of the object
+print(VpnSettings.to_json())
+
+# convert the object into a dict
+vpn_settings_dict = vpn_settings_instance.to_dict()
+# create an instance of VpnSettings from a dict
+vpn_settings_from_dict = VpnSettings.from_dict(vpn_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/VpnSettingsVpn.md b/scm/device_settings/docs/VpnSettingsVpn.md
new file mode 100644
index 00000000..40ceb7aa
--- /dev/null
+++ b/scm/device_settings/docs/VpnSettingsVpn.md
@@ -0,0 +1,29 @@
+# VpnSettingsVpn
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ikev2** | [**VpnSettingsVpnIkev2**](VpnSettingsVpnIkev2.md) | | [optional]
+
+## Example
+
+```python
+from scm.device_settings.models.vpn_settings_vpn import VpnSettingsVpn
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of VpnSettingsVpn from a JSON string
+vpn_settings_vpn_instance = VpnSettingsVpn.from_json(json)
+# print the JSON string representation of the object
+print(VpnSettingsVpn.to_json())
+
+# convert the object into a dict
+vpn_settings_vpn_dict = vpn_settings_vpn_instance.to_dict()
+# create an instance of VpnSettingsVpn from a dict
+vpn_settings_vpn_from_dict = VpnSettingsVpn.from_dict(vpn_settings_vpn_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/docs/VpnSettingsVpnIkev2.md b/scm/device_settings/docs/VpnSettingsVpnIkev2.md
new file mode 100644
index 00000000..d3883f70
--- /dev/null
+++ b/scm/device_settings/docs/VpnSettingsVpnIkev2.md
@@ -0,0 +1,31 @@
+# VpnSettingsVpnIkev2
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**certificate_cache_size** | **int** | Maximum cached certificates | [optional] [default to 500]
+**cookie_threshold** | **int** | Cookie activation threshold | [optional] [default to 500]
+**max_half_opened_sa** | **int** | Maximum half-opened SA | [optional] [default to 65535]
+
+## Example
+
+```python
+from scm.device_settings.models.vpn_settings_vpn_ikev2 import VpnSettingsVpnIkev2
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of VpnSettingsVpnIkev2 from a JSON string
+vpn_settings_vpn_ikev2_instance = VpnSettingsVpnIkev2.from_json(json)
+# print the JSON string representation of the object
+print(VpnSettingsVpnIkev2.to_json())
+
+# convert the object into a dict
+vpn_settings_vpn_ikev2_dict = vpn_settings_vpn_ikev2_instance.to_dict()
+# create an instance of VpnSettingsVpnIkev2 from a dict
+vpn_settings_vpn_ikev2_from_dict = VpnSettingsVpnIkev2.from_dict(vpn_settings_vpn_ikev2_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/device_settings/exceptions.py b/scm/device_settings/exceptions.py
new file mode 100644
index 00000000..d6285266
--- /dev/null
+++ b/scm/device_settings/exceptions.py
@@ -0,0 +1,200 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+from typing import Any, Optional
+from typing_extensions import Self
+
+class OpenApiException(Exception):
+ """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+ def __init__(self, msg, path_to_item=None, valid_classes=None,
+ key_type=None) -> None:
+ """ Raises an exception for TypeErrors
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list): a list of keys an indices to get to the
+ current_item
+ None if unset
+ valid_classes (tuple): the primitive classes that current item
+ should be an instance of
+ None if unset
+ key_type (bool): False if our value is a value in a dict
+ True if it is a key in a dict
+ False if our item is an item in a list
+ None if unset
+ """
+ self.path_to_item = path_to_item
+ self.valid_classes = valid_classes
+ self.key_type = key_type
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list) the path to the exception in the
+ received_data dict. None if unset
+ """
+
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Raised when an attribute reference or assignment fails.
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+ def __init__(
+ self,
+ status=None,
+ reason=None,
+ http_resp=None,
+ *,
+ body: Optional[str] = None,
+ data: Optional[Any] = None,
+ ) -> None:
+ self.status = status
+ self.reason = reason
+ self.body = body
+ self.data = data
+ self.headers = None
+
+ if http_resp:
+ if self.status is None:
+ self.status = http_resp.status
+ if self.reason is None:
+ self.reason = http_resp.reason
+ if self.body is None:
+ try:
+ self.body = http_resp.data.decode('utf-8')
+ except Exception:
+ pass
+ self.headers = http_resp.getheaders()
+
+ @classmethod
+ def from_response(
+ cls,
+ *,
+ http_resp,
+ body: Optional[str],
+ data: Optional[Any],
+ ) -> Self:
+ if http_resp.status == 400:
+ raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 401:
+ raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 403:
+ raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 404:
+ raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+ if 500 <= http_resp.status <= 599:
+ raise ServiceException(http_resp=http_resp, body=body, data=data)
+ raise ApiException(http_resp=http_resp, body=body, data=data)
+
+ def __str__(self):
+ """Custom error messages for exception"""
+ error_message = "({0})\n"\
+ "Reason: {1}\n".format(self.status, self.reason)
+ if self.headers:
+ error_message += "HTTP response headers: {0}\n".format(
+ self.headers)
+
+ if self.data or self.body:
+ error_message += "HTTP response body: {0}\n".format(self.data or self.body)
+
+ return error_message
+
+
+class BadRequestException(ApiException):
+ pass
+
+
+class NotFoundException(ApiException):
+ pass
+
+
+class UnauthorizedException(ApiException):
+ pass
+
+
+class ForbiddenException(ApiException):
+ pass
+
+
+class ServiceException(ApiException):
+ pass
+
+
+def render_path(path_to_item):
+ """Returns a string representation of a path"""
+ result = ""
+ for pth in path_to_item:
+ if isinstance(pth, int):
+ result += "[{0}]".format(pth)
+ else:
+ result += "['{0}']".format(pth)
+ return result
diff --git a/scm/device_settings/models/__init__.py b/scm/device_settings/models/__init__.py
new file mode 100644
index 00000000..6d81b9da
--- /dev/null
+++ b/scm/device_settings/models/__init__.py
@@ -0,0 +1,112 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+# import models into model package
+from scm.device_settings.models.authentication_settings import AuthenticationSettings
+from scm.device_settings.models.authentication_settings_authentication import AuthenticationSettingsAuthentication
+from scm.device_settings.models.content_id_settings import ContentIdSettings
+from scm.device_settings.models.content_id_settings_content_id import ContentIdSettingsContentId
+from scm.device_settings.models.content_id_settings_content_id_application import ContentIdSettingsContentIdApplication
+from scm.device_settings.models.device_redistribution_collector import DeviceRedistributionCollector
+from scm.device_settings.models.device_redistribution_collector_redistribution_collector import DeviceRedistributionCollectorRedistributionCollector
+from scm.device_settings.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.device_settings.models.general_settings import GeneralSettings
+from scm.device_settings.models.general_settings_general import GeneralSettingsGeneral
+from scm.device_settings.models.general_settings_general_geo_location import GeneralSettingsGeneralGeoLocation
+from scm.device_settings.models.general_settings_general_setting import GeneralSettingsGeneralSetting
+from scm.device_settings.models.general_settings_general_setting_management import GeneralSettingsGeneralSettingManagement
+from scm.device_settings.models.generic_error import GenericError
+from scm.device_settings.models.ha_configurations import HaConfigurations
+from scm.device_settings.models.ha_configurations_group import HaConfigurationsGroup
+from scm.device_settings.models.ha_configurations_group_election_option import HaConfigurationsGroupElectionOption
+from scm.device_settings.models.ha_configurations_group_mode import HaConfigurationsGroupMode
+from scm.device_settings.models.ha_configurations_group_mode_active_passive import HaConfigurationsGroupModeActivePassive
+from scm.device_settings.models.ha_configurations_group_monitoring import HaConfigurationsGroupMonitoring
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring import HaConfigurationsGroupMonitoringLinkMonitoring
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring_link_group_inner import HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring import HaConfigurationsGroupMonitoringPathMonitoring
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group import HaConfigurationsGroupMonitoringPathMonitoringPathGroup
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner
+from scm.device_settings.models.ha_configurations_group_state_synchronization import HaConfigurationsGroupStateSynchronization
+from scm.device_settings.models.ha_configurations_group_state_synchronization_ha2_keep_alive import HaConfigurationsGroupStateSynchronizationHa2KeepAlive
+from scm.device_settings.models.ha_configurations_interface import HaConfigurationsInterface
+from scm.device_settings.models.ha_configurations_interface_ha1 import HaConfigurationsInterfaceHa1
+from scm.device_settings.models.ha_configurations_interface_ha1_backup import HaConfigurationsInterfaceHa1Backup
+from scm.device_settings.models.ha_configurations_interface_ha2 import HaConfigurationsInterfaceHa2
+from scm.device_settings.models.ha_configurations_interface_ha2_backup import HaConfigurationsInterfaceHa2Backup
+from scm.device_settings.models.ha_devices import HaDevices
+from scm.device_settings.models.ha_devices_ha_devices_inner import HaDevicesHaDevicesInner
+from scm.device_settings.models.list_ha_devices200_response import ListHADevices200Response
+from scm.device_settings.models.management_interface import ManagementInterface
+from scm.device_settings.models.management_interface_management_interface import ManagementInterfaceManagementInterface
+from scm.device_settings.models.management_interface_management_interface_mgmt_type import ManagementInterfaceManagementInterfaceMgmtType
+from scm.device_settings.models.management_interface_management_interface_mgmt_type_dhcp_client import ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient
+from scm.device_settings.models.management_interface_management_interface_permitted_ip_inner import ManagementInterfaceManagementInterfacePermittedIpInner
+from scm.device_settings.models.management_interface_management_interface_service import ManagementInterfaceManagementInterfaceService
+from scm.device_settings.models.motd_banner_settings import MotdBannerSettings
+from scm.device_settings.models.motd_banner_settings_motd_and_banner import MotdBannerSettingsMotdAndBanner
+from scm.device_settings.models.motd_color import MotdColor
+from scm.device_settings.models.service_route import ServiceRoute
+from scm.device_settings.models.service_route_route import ServiceRouteRoute
+from scm.device_settings.models.service_route_route_destination_inner import ServiceRouteRouteDestinationInner
+from scm.device_settings.models.service_route_route_destination_inner_source import ServiceRouteRouteDestinationInnerSource
+from scm.device_settings.models.service_route_route_service_inner import ServiceRouteRouteServiceInner
+from scm.device_settings.models.service_route_route_service_inner_source import ServiceRouteRouteServiceInnerSource
+from scm.device_settings.models.service_route_route_service_inner_source_v6 import ServiceRouteRouteServiceInnerSourceV6
+from scm.device_settings.models.service_settings import ServiceSettings
+from scm.device_settings.models.service_settings_services import ServiceSettingsServices
+from scm.device_settings.models.service_settings_services_dns_setting import ServiceSettingsServicesDnsSetting
+from scm.device_settings.models.service_settings_services_dns_setting_servers import ServiceSettingsServicesDnsSettingServers
+from scm.device_settings.models.service_settings_services_ntp_servers import ServiceSettingsServicesNtpServers
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server import ServiceSettingsServicesNtpServersPrimaryNtpServer
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5 import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5
+from scm.device_settings.models.session_settings import SessionSettings
+from scm.device_settings.models.session_settings_session_settings import SessionSettingsSessionSettings
+from scm.device_settings.models.session_settings_session_settings_config import SessionSettingsSessionSettingsConfig
+from scm.device_settings.models.session_settings_session_settings_icmpv6_rate_limit import SessionSettingsSessionSettingsIcmpv6RateLimit
+from scm.device_settings.models.session_settings_session_settings_jumbo_frame import SessionSettingsSessionSettingsJumboFrame
+from scm.device_settings.models.session_settings_session_settings_nat import SessionSettingsSessionSettingsNat
+from scm.device_settings.models.session_settings_session_settings_nat64 import SessionSettingsSessionSettingsNat64
+from scm.device_settings.models.session_timeouts import SessionTimeouts
+from scm.device_settings.models.session_timeouts_session_timeouts import SessionTimeoutsSessionTimeouts
+from scm.device_settings.models.tcp_settings import TcpSettings
+from scm.device_settings.models.tcp_settings_tcp import TcpSettingsTcp
+from scm.device_settings.models.update_schedule import UpdateSchedule
+from scm.device_settings.models.update_schedule_update_schedule import UpdateScheduleUpdateSchedule
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus import UpdateScheduleUpdateScheduleAntiVirus
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring import UpdateScheduleUpdateScheduleAntiVirusRecurring
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_daily import UpdateScheduleUpdateScheduleAntiVirusRecurringDaily
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_hourly import UpdateScheduleUpdateScheduleAntiVirusRecurringHourly
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_weekly import UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly
+from scm.device_settings.models.update_schedule_update_schedule_threats import UpdateScheduleUpdateScheduleThreats
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring import UpdateScheduleUpdateScheduleThreatsRecurring
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_daily import UpdateScheduleUpdateScheduleThreatsRecurringDaily
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_every30_mins import UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_hourly import UpdateScheduleUpdateScheduleThreatsRecurringHourly
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_weekly import UpdateScheduleUpdateScheduleThreatsRecurringWeekly
+from scm.device_settings.models.update_schedule_update_schedule_wildfire import UpdateScheduleUpdateScheduleWildfire
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring import UpdateScheduleUpdateScheduleWildfireRecurring
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every15_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every30_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_hour import UpdateScheduleUpdateScheduleWildfireRecurringEveryHour
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_min import UpdateScheduleUpdateScheduleWildfireRecurringEveryMin
+from scm.device_settings.models.vpn_settings import VpnSettings
+from scm.device_settings.models.vpn_settings_vpn import VpnSettingsVpn
+from scm.device_settings.models.vpn_settings_vpn_ikev2 import VpnSettingsVpnIkev2
diff --git a/scm/device_settings/models/authentication_settings.py b/scm/device_settings/models/authentication_settings.py
new file mode 100644
index 00000000..89409f77
--- /dev/null
+++ b/scm/device_settings/models/authentication_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.authentication_settings_authentication import AuthenticationSettingsAuthentication
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationSettings(BaseModel):
+ """
+ AuthenticationSettings
+ """ # noqa: E501
+ authentication: Optional[AuthenticationSettingsAuthentication] = None
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="UUID of the resource")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["authentication", "device", "folder", "id", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of authentication
+ if self.authentication:
+ _dict['authentication'] = self.authentication.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authentication": AuthenticationSettingsAuthentication.from_dict(obj["authentication"]) if obj.get("authentication") is not None else None,
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/authentication_settings_authentication.py b/scm/device_settings/models/authentication_settings_authentication.py
new file mode 100644
index 00000000..6ce0ea61
--- /dev/null
+++ b/scm/device_settings/models/authentication_settings_authentication.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationSettingsAuthentication(BaseModel):
+ """
+ AuthenticationSettingsAuthentication
+ """ # noqa: E501
+ accounting_server_profile: Optional[StrictStr] = Field(default=None, description="Accounting server profile")
+ authentication_profile: Optional[StrictStr] = Field(default=None, description="Authentication profile")
+ certificate_profile: Optional[StrictStr] = Field(default=None, description="Certificate profile")
+ __properties: ClassVar[List[str]] = ["accounting_server_profile", "authentication_profile", "certificate_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationSettingsAuthentication from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationSettingsAuthentication from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "accounting_server_profile": obj.get("accounting_server_profile"),
+ "authentication_profile": obj.get("authentication_profile"),
+ "certificate_profile": obj.get("certificate_profile")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/content_id_settings.py b/scm/device_settings/models/content_id_settings.py
new file mode 100644
index 00000000..cad2ddf8
--- /dev/null
+++ b/scm/device_settings/models/content_id_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.content_id_settings_content_id import ContentIdSettingsContentId
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ContentIdSettings(BaseModel):
+ """
+ ContentIdSettings
+ """ # noqa: E501
+ content_id: Optional[ContentIdSettingsContentId] = None
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["content_id", "device", "folder", "id", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ContentIdSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of content_id
+ if self.content_id:
+ _dict['content_id'] = self.content_id.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ContentIdSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "content_id": ContentIdSettingsContentId.from_dict(obj["content_id"]) if obj.get("content_id") is not None else None,
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/content_id_settings_content_id.py b/scm/device_settings/models/content_id_settings_content_id.py
new file mode 100644
index 00000000..d218dad6
--- /dev/null
+++ b/scm/device_settings/models/content_id_settings_content_id.py
@@ -0,0 +1,107 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.content_id_settings_content_id_application import ContentIdSettingsContentIdApplication
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ContentIdSettingsContentId(BaseModel):
+ """
+ ContentIdSettingsContentId
+ """ # noqa: E501
+ allow_forward_decrypted_content: Optional[StrictBool] = False
+ allow_http_range: Optional[StrictBool] = True
+ application: Optional[ContentIdSettingsContentIdApplication] = None
+ extended_capture_segment: Optional[StrictInt] = 5
+ strip_x_fwd_for: Optional[StrictBool] = False
+ tcp_bypass_exceed_queue: Optional[StrictBool] = True
+ udp_bypass_exceed_queue: Optional[StrictBool] = True
+ x_forwarded_for: Optional[Annotated[str, Field(strict=True)]] = '0'
+ __properties: ClassVar[List[str]] = ["allow_forward_decrypted_content", "allow_http_range", "application", "extended_capture_segment", "strip_x_fwd_for", "tcp_bypass_exceed_queue", "udp_bypass_exceed_queue", "x_forwarded_for"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ContentIdSettingsContentId from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of application
+ if self.application:
+ _dict['application'] = self.application.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ContentIdSettingsContentId from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "allow_forward_decrypted_content": obj.get("allow_forward_decrypted_content") if obj.get("allow_forward_decrypted_content") is not None else False,
+ "allow_http_range": obj.get("allow_http_range") if obj.get("allow_http_range") is not None else True,
+ "application": ContentIdSettingsContentIdApplication.from_dict(obj["application"]) if obj.get("application") is not None else None,
+ "extended_capture_segment": obj.get("extended_capture_segment") if obj.get("extended_capture_segment") is not None else 5,
+ "strip_x_fwd_for": obj.get("strip_x_fwd_for") if obj.get("strip_x_fwd_for") is not None else False,
+ "tcp_bypass_exceed_queue": obj.get("tcp_bypass_exceed_queue") if obj.get("tcp_bypass_exceed_queue") is not None else True,
+ "udp_bypass_exceed_queue": obj.get("udp_bypass_exceed_queue") if obj.get("udp_bypass_exceed_queue") is not None else True,
+ "x_forwarded_for": obj.get("x_forwarded_for") if obj.get("x_forwarded_for") is not None else '0'
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/content_id_settings_content_id_application.py b/scm/device_settings/models/content_id_settings_content_id_application.py
new file mode 100644
index 00000000..9be9e748
--- /dev/null
+++ b/scm/device_settings/models/content_id_settings_content_id_application.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ContentIdSettingsContentIdApplication(BaseModel):
+ """
+ ContentIdSettingsContentIdApplication
+ """ # noqa: E501
+ bypass_exceed_queue: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["bypass_exceed_queue"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ContentIdSettingsContentIdApplication from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ContentIdSettingsContentIdApplication from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "bypass_exceed_queue": obj.get("bypass_exceed_queue") if obj.get("bypass_exceed_queue") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/device_redistribution_collector.py b/scm/device_settings/models/device_redistribution_collector.py
new file mode 100644
index 00000000..1267425a
--- /dev/null
+++ b/scm/device_settings/models/device_redistribution_collector.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.device_redistribution_collector_redistribution_collector import DeviceRedistributionCollectorRedistributionCollector
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceRedistributionCollector(BaseModel):
+ """
+ DeviceRedistributionCollector
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ redistribution_collector: Optional[DeviceRedistributionCollectorRedistributionCollector] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "redistribution_collector", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of DeviceRedistributionCollector from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of redistribution_collector
+ if self.redistribution_collector:
+ _dict['redistribution_collector'] = self.redistribution_collector.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of DeviceRedistributionCollector from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "redistribution_collector": DeviceRedistributionCollectorRedistributionCollector.from_dict(obj["redistribution_collector"]) if obj.get("redistribution_collector") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/device_redistribution_collector_redistribution_collector.py b/scm/device_settings/models/device_redistribution_collector_redistribution_collector.py
new file mode 100644
index 00000000..af853b9f
--- /dev/null
+++ b/scm/device_settings/models/device_redistribution_collector_redistribution_collector.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class DeviceRedistributionCollectorRedistributionCollector(BaseModel):
+ """
+ DeviceRedistributionCollectorRedistributionCollector
+ """ # noqa: E501
+ interface: Optional[StrictStr] = Field(default=None, description="User-ID collector interface")
+ __properties: ClassVar[List[str]] = ["interface"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of DeviceRedistributionCollectorRedistributionCollector from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of DeviceRedistributionCollectorRedistributionCollector from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "interface": obj.get("interface")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/error_detail_cause_info.py b/scm/device_settings/models/error_detail_cause_info.py
new file mode 100644
index 00000000..d2827194
--- /dev/null
+++ b/scm/device_settings/models/error_detail_cause_info.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorDetailCauseInfo(BaseModel):
+ """
+ ErrorDetailCauseInfo
+ """ # noqa: E501
+ code: Optional[StrictStr] = None
+ details: Optional[Dict[str, Any]] = None
+ help: Optional[StrictStr] = None
+ message: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["code", "details", "help", "message"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "code": obj.get("code"),
+ "details": obj.get("details"),
+ "help": obj.get("help"),
+ "message": obj.get("message")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/general_settings.py b/scm/device_settings/models/general_settings.py
new file mode 100644
index 00000000..667f13a1
--- /dev/null
+++ b/scm/device_settings/models/general_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.general_settings_general import GeneralSettingsGeneral
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GeneralSettings(BaseModel):
+ """
+ GeneralSettings
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ general: Optional[GeneralSettingsGeneral] = None
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "general", "id", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GeneralSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of general
+ if self.general:
+ _dict['general'] = self.general.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GeneralSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "general": GeneralSettingsGeneral.from_dict(obj["general"]) if obj.get("general") is not None else None,
+ "id": obj.get("id"),
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/general_settings_general.py b/scm/device_settings/models/general_settings_general.py
new file mode 100644
index 00000000..9adf8fd2
--- /dev/null
+++ b/scm/device_settings/models/general_settings_general.py
@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.general_settings_general_geo_location import GeneralSettingsGeneralGeoLocation
+from scm.device_settings.models.general_settings_general_setting import GeneralSettingsGeneralSetting
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GeneralSettingsGeneral(BaseModel):
+ """
+ GeneralSettingsGeneral
+ """ # noqa: E501
+ ack_login_banner: Optional[StrictBool] = Field(default=False, description="Force admins to acknowledge login banner")
+ domain: Optional[StrictStr] = Field(default=None, description="DNS domain")
+ geo_location: Optional[GeneralSettingsGeneralGeoLocation] = None
+ locale: Optional[StrictStr] = Field(default='en', description="Locale")
+ login_banner: Optional[StrictStr] = Field(default=None, description="Logon banner")
+ setting: Optional[GeneralSettingsGeneralSetting] = None
+ ssl_tls_service_profile: Optional[StrictStr] = Field(default=None, description="SSL/TLS service profile")
+ timezone: Optional[StrictStr] = Field(default=None, description="Timezone")
+ __properties: ClassVar[List[str]] = ["ack_login_banner", "domain", "geo_location", "locale", "login_banner", "setting", "ssl_tls_service_profile", "timezone"]
+
+ @field_validator('locale')
+ def locale_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['en', 'es', 'ja', 'fr', 'zh_CN', 'zh_TW']):
+ raise ValueError("must be one of enum values ('en', 'es', 'ja', 'fr', 'zh_CN', 'zh_TW')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneral from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of geo_location
+ if self.geo_location:
+ _dict['geo_location'] = self.geo_location.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of setting
+ if self.setting:
+ _dict['setting'] = self.setting.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneral from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ack_login_banner": obj.get("ack_login_banner") if obj.get("ack_login_banner") is not None else False,
+ "domain": obj.get("domain"),
+ "geo_location": GeneralSettingsGeneralGeoLocation.from_dict(obj["geo_location"]) if obj.get("geo_location") is not None else None,
+ "locale": obj.get("locale") if obj.get("locale") is not None else 'en',
+ "login_banner": obj.get("login_banner"),
+ "setting": GeneralSettingsGeneralSetting.from_dict(obj["setting"]) if obj.get("setting") is not None else None,
+ "ssl_tls_service_profile": obj.get("ssl_tls_service_profile"),
+ "timezone": obj.get("timezone")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/general_settings_general_geo_location.py b/scm/device_settings/models/general_settings_general_geo_location.py
new file mode 100644
index 00000000..2f85ed26
--- /dev/null
+++ b/scm/device_settings/models/general_settings_general_geo_location.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GeneralSettingsGeneralGeoLocation(BaseModel):
+ """
+ Geographic coordinates
+ """ # noqa: E501
+ latitude: Optional[StrictStr] = Field(default=None, description="Latitude")
+ longitude: Optional[StrictStr] = Field(default=None, description="Longitude")
+ __properties: ClassVar[List[str]] = ["latitude", "longitude"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneralGeoLocation from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneralGeoLocation from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "latitude": obj.get("latitude"),
+ "longitude": obj.get("longitude")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/general_settings_general_setting.py b/scm/device_settings/models/general_settings_general_setting.py
new file mode 100644
index 00000000..a384cc9f
--- /dev/null
+++ b/scm/device_settings/models/general_settings_general_setting.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.general_settings_general_setting_management import GeneralSettingsGeneralSettingManagement
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GeneralSettingsGeneralSetting(BaseModel):
+ """
+ GeneralSettingsGeneralSetting
+ """ # noqa: E501
+ auto_mac_detect: Optional[StrictBool] = Field(default=False, description="Use hypervisor assigned MAC addresses")
+ fail_open: Optional[StrictBool] = Field(default=False, description="Fail open")
+ management: Optional[GeneralSettingsGeneralSettingManagement] = None
+ tunnel_acceleration: Optional[StrictBool] = Field(default=True, description="Tunnel acceleration")
+ __properties: ClassVar[List[str]] = ["auto_mac_detect", "fail_open", "management", "tunnel_acceleration"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneralSetting from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of management
+ if self.management:
+ _dict['management'] = self.management.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneralSetting from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "auto_mac_detect": obj.get("auto_mac_detect") if obj.get("auto_mac_detect") is not None else False,
+ "fail_open": obj.get("fail_open") if obj.get("fail_open") is not None else False,
+ "management": GeneralSettingsGeneralSettingManagement.from_dict(obj["management"]) if obj.get("management") is not None else None,
+ "tunnel_acceleration": obj.get("tunnel_acceleration") if obj.get("tunnel_acceleration") is not None else True
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/general_settings_general_setting_management.py b/scm/device_settings/models/general_settings_general_setting_management.py
new file mode 100644
index 00000000..589ea535
--- /dev/null
+++ b/scm/device_settings/models/general_settings_general_setting_management.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GeneralSettingsGeneralSettingManagement(BaseModel):
+ """
+ GeneralSettingsGeneralSettingManagement
+ """ # noqa: E501
+ auto_acquire_commit_lock: Optional[StrictBool] = Field(default=False, description="Automatically acquire commit lock")
+ enable_certificate_expiration_check: Optional[StrictBool] = Field(default=False, description="Certificate expiration check")
+ __properties: ClassVar[List[str]] = ["auto_acquire_commit_lock", "enable_certificate_expiration_check"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneralSettingManagement from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GeneralSettingsGeneralSettingManagement from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "auto_acquire_commit_lock": obj.get("auto_acquire_commit_lock") if obj.get("auto_acquire_commit_lock") is not None else False,
+ "enable_certificate_expiration_check": obj.get("enable_certificate_expiration_check") if obj.get("enable_certificate_expiration_check") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/generic_error.py b/scm/device_settings/models/generic_error.py
new file mode 100644
index 00000000..f75c14c2
--- /dev/null
+++ b/scm/device_settings/models/generic_error.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.error_detail_cause_info import ErrorDetailCauseInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GenericError(BaseModel):
+ """
+ GenericError
+ """ # noqa: E501
+ errors: Optional[List[ErrorDetailCauseInfo]] = Field(default=None, alias="_errors")
+ request_id: Optional[StrictStr] = Field(default=None, alias="_request_id")
+ __properties: ClassVar[List[str]] = ["_errors", "_request_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GenericError from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+ _items = []
+ if self.errors:
+ for _item_errors in self.errors:
+ if _item_errors:
+ _items.append(_item_errors.to_dict())
+ _dict['_errors'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GenericError from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "_errors": [ErrorDetailCauseInfo.from_dict(_item) for _item in obj["_errors"]] if obj.get("_errors") is not None else None,
+ "_request_id": obj.get("_request_id")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations.py b/scm/device_settings/models/ha_configurations.py
new file mode 100644
index 00000000..ad666f32
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations.py
@@ -0,0 +1,137 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.ha_configurations_group import HaConfigurationsGroup
+from scm.device_settings.models.ha_configurations_interface import HaConfigurationsInterface
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurations(BaseModel):
+ """
+ HaConfigurations
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ enabled: Optional[StrictBool] = True
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ group: HaConfigurationsGroup
+ interface: HaConfigurationsInterface
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "enabled", "folder", "group", "interface", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurations from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of group
+ if self.group:
+ _dict['group'] = self.group.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of interface
+ if self.interface:
+ _dict['interface'] = self.interface.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurations from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "enabled": obj.get("enabled") if obj.get("enabled") is not None else True,
+ "folder": obj.get("folder"),
+ "group": HaConfigurationsGroup.from_dict(obj["group"]) if obj.get("group") is not None else None,
+ "interface": HaConfigurationsInterface.from_dict(obj["interface"]) if obj.get("interface") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group.py b/scm/device_settings/models/ha_configurations_group.py
new file mode 100644
index 00000000..94147c4f
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group.py
@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.ha_configurations_group_election_option import HaConfigurationsGroupElectionOption
+from scm.device_settings.models.ha_configurations_group_mode import HaConfigurationsGroupMode
+from scm.device_settings.models.ha_configurations_group_monitoring import HaConfigurationsGroupMonitoring
+from scm.device_settings.models.ha_configurations_group_state_synchronization import HaConfigurationsGroupStateSynchronization
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroup(BaseModel):
+ """
+ HaConfigurationsGroup
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default='N/A', description="HA group description (not currently used)")
+ election_option: HaConfigurationsGroupElectionOption
+ group_id: Annotated[int, Field(le=63, strict=True, ge=1)] = Field(description="HA group ID")
+ mode: HaConfigurationsGroupMode
+ monitoring: HaConfigurationsGroupMonitoring
+ peer_ip: StrictStr = Field(description="Peer HA1 IP address")
+ peer_ip_backup: Optional[StrictStr] = Field(default=None, description="Peer HA1 backup IP address")
+ peer_serial: StrictStr = Field(description="Serial number of the HA peer")
+ state_synchronization: HaConfigurationsGroupStateSynchronization
+ __properties: ClassVar[List[str]] = ["description", "election_option", "group_id", "mode", "monitoring", "peer_ip", "peer_ip_backup", "peer_serial", "state_synchronization"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroup from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of election_option
+ if self.election_option:
+ _dict['election_option'] = self.election_option.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of mode
+ if self.mode:
+ _dict['mode'] = self.mode.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of monitoring
+ if self.monitoring:
+ _dict['monitoring'] = self.monitoring.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of state_synchronization
+ if self.state_synchronization:
+ _dict['state_synchronization'] = self.state_synchronization.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroup from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description") if obj.get("description") is not None else 'N/A',
+ "election_option": HaConfigurationsGroupElectionOption.from_dict(obj["election_option"]) if obj.get("election_option") is not None else None,
+ "group_id": obj.get("group_id"),
+ "mode": HaConfigurationsGroupMode.from_dict(obj["mode"]) if obj.get("mode") is not None else None,
+ "monitoring": HaConfigurationsGroupMonitoring.from_dict(obj["monitoring"]) if obj.get("monitoring") is not None else None,
+ "peer_ip": obj.get("peer_ip"),
+ "peer_ip_backup": obj.get("peer_ip_backup"),
+ "peer_serial": obj.get("peer_serial"),
+ "state_synchronization": HaConfigurationsGroupStateSynchronization.from_dict(obj["state_synchronization"]) if obj.get("state_synchronization") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_election_option.py b/scm/device_settings/models/ha_configurations_group_election_option.py
new file mode 100644
index 00000000..6e9aab9a
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_election_option.py
@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupElectionOption(BaseModel):
+ """
+ HaConfigurationsGroupElectionOption
+ """ # noqa: E501
+ device_priority: Optional[Annotated[int, Field(le=2, strict=True, ge=1)]] = Field(default=None, description="Device priority (1 = primary, 2 = secondary)")
+ ha_role: Optional[StrictStr] = Field(default=None, description="Device HA role")
+ heartbeat_backup: Optional[StrictBool] = None
+ preemptive: Optional[StrictBool] = Field(default=False, description="Preemption enabled?")
+ __properties: ClassVar[List[str]] = ["device_priority", "ha_role", "heartbeat_backup", "preemptive"]
+
+ @field_validator('ha_role')
+ def ha_role_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['primary', 'secondary']):
+ raise ValueError("must be one of enum values ('primary', 'secondary')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupElectionOption from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupElectionOption from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device_priority": obj.get("device_priority"),
+ "ha_role": obj.get("ha_role"),
+ "heartbeat_backup": obj.get("heartbeat_backup"),
+ "preemptive": obj.get("preemptive") if obj.get("preemptive") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_mode.py b/scm/device_settings/models/ha_configurations_group_mode.py
new file mode 100644
index 00000000..765a7b60
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_mode.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_configurations_group_mode_active_passive import HaConfigurationsGroupModeActivePassive
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMode(BaseModel):
+ """
+ HaConfigurationsGroupMode
+ """ # noqa: E501
+ active_passive: Optional[HaConfigurationsGroupModeActivePassive] = None
+ __properties: ClassVar[List[str]] = ["active_passive"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMode from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of active_passive
+ if self.active_passive:
+ _dict['active_passive'] = self.active_passive.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMode from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "active_passive": HaConfigurationsGroupModeActivePassive.from_dict(obj["active_passive"]) if obj.get("active_passive") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_mode_active_passive.py b/scm/device_settings/models/ha_configurations_group_mode_active_passive.py
new file mode 100644
index 00000000..1a4bc8ac
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_mode_active_passive.py
@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupModeActivePassive(BaseModel):
+ """
+ HaConfigurationsGroupModeActivePassive
+ """ # noqa: E501
+ monitor_fail_hold_down_time: Optional[Annotated[int, Field(le=60000, strict=True, ge=1000)]] = Field(default=3000, description="Monitor hold time (milliseconds)")
+ passive_link_state: Optional[StrictStr] = Field(default=None, description="Passive link state")
+ __properties: ClassVar[List[str]] = ["monitor_fail_hold_down_time", "passive_link_state"]
+
+ @field_validator('passive_link_state')
+ def passive_link_state_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['shutdown', 'auto']):
+ raise ValueError("must be one of enum values ('shutdown', 'auto')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupModeActivePassive from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupModeActivePassive from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "monitor_fail_hold_down_time": obj.get("monitor_fail_hold_down_time") if obj.get("monitor_fail_hold_down_time") is not None else 3000,
+ "passive_link_state": obj.get("passive_link_state")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_monitoring.py b/scm/device_settings/models/ha_configurations_group_monitoring.py
new file mode 100644
index 00000000..faaa0e47
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_monitoring.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring import HaConfigurationsGroupMonitoringLinkMonitoring
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring import HaConfigurationsGroupMonitoringPathMonitoring
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMonitoring(BaseModel):
+ """
+ HaConfigurationsGroupMonitoring
+ """ # noqa: E501
+ link_monitoring: Optional[HaConfigurationsGroupMonitoringLinkMonitoring] = None
+ path_monitoring: Optional[HaConfigurationsGroupMonitoringPathMonitoring] = None
+ __properties: ClassVar[List[str]] = ["link_monitoring", "path_monitoring"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoring from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of link_monitoring
+ if self.link_monitoring:
+ _dict['link_monitoring'] = self.link_monitoring.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of path_monitoring
+ if self.path_monitoring:
+ _dict['path_monitoring'] = self.path_monitoring.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoring from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "link_monitoring": HaConfigurationsGroupMonitoringLinkMonitoring.from_dict(obj["link_monitoring"]) if obj.get("link_monitoring") is not None else None,
+ "path_monitoring": HaConfigurationsGroupMonitoringPathMonitoring.from_dict(obj["path_monitoring"]) if obj.get("path_monitoring") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_monitoring_link_monitoring.py b/scm/device_settings/models/ha_configurations_group_monitoring_link_monitoring.py
new file mode 100644
index 00000000..cd5b6ca8
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_monitoring_link_monitoring.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_configurations_group_monitoring_link_monitoring_link_group_inner import HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMonitoringLinkMonitoring(BaseModel):
+ """
+ HaConfigurationsGroupMonitoringLinkMonitoring
+ """ # noqa: E501
+ enabled: Optional[StrictBool] = Field(default=False, description="Enable link monitoring")
+ failure_condition: Optional[StrictStr] = Field(default=None, description="Failure condition")
+ link_group: Optional[List[HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner]] = Field(default=None, description="Link groups")
+ __properties: ClassVar[List[str]] = ["enabled", "failure_condition", "link_group"]
+
+ @field_validator('failure_condition')
+ def failure_condition_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['any', 'all']):
+ raise ValueError("must be one of enum values ('any', 'all')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringLinkMonitoring from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in link_group (list)
+ _items = []
+ if self.link_group:
+ for _item_link_group in self.link_group:
+ if _item_link_group:
+ _items.append(_item_link_group.to_dict())
+ _dict['link_group'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringLinkMonitoring from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "enabled": obj.get("enabled") if obj.get("enabled") is not None else False,
+ "failure_condition": obj.get("failure_condition"),
+ "link_group": [HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner.from_dict(_item) for _item in obj["link_group"]] if obj.get("link_group") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_monitoring_link_monitoring_link_group_inner.py b/scm/device_settings/models/ha_configurations_group_monitoring_link_monitoring_link_group_inner.py
new file mode 100644
index 00000000..ac4baa54
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_monitoring_link_monitoring_link_group_inner.py
@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner(BaseModel):
+ """
+ HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner
+ """ # noqa: E501
+ enabled: Optional[StrictBool] = Field(default=True, description="Enable link group?")
+ failure_condition: Optional[StrictStr] = Field(default=None, description="Failure condition")
+ interface: Optional[List[StrictStr]] = Field(default=None, description="Interfaces monitored")
+ name: StrictStr = Field(description="Link group name")
+ __properties: ClassVar[List[str]] = ["enabled", "failure_condition", "interface", "name"]
+
+ @field_validator('failure_condition')
+ def failure_condition_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['any', 'all']):
+ raise ValueError("must be one of enum values ('any', 'all')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringLinkMonitoringLinkGroupInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "enabled": obj.get("enabled") if obj.get("enabled") is not None else True,
+ "failure_condition": obj.get("failure_condition"),
+ "interface": obj.get("interface"),
+ "name": obj.get("name")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring.py b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring.py
new file mode 100644
index 00000000..bc0f421d
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring.py
@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group import HaConfigurationsGroupMonitoringPathMonitoringPathGroup
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMonitoringPathMonitoring(BaseModel):
+ """
+ HaConfigurationsGroupMonitoringPathMonitoring
+ """ # noqa: E501
+ enabled: Optional[StrictBool] = Field(default=False, description="Enable path monitoring?")
+ failure_condition: Optional[StrictStr] = None
+ path_group: Optional[HaConfigurationsGroupMonitoringPathMonitoringPathGroup] = None
+ __properties: ClassVar[List[str]] = ["enabled", "failure_condition", "path_group"]
+
+ @field_validator('failure_condition')
+ def failure_condition_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['any', 'all']):
+ raise ValueError("must be one of enum values ('any', 'all')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoring from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of path_group
+ if self.path_group:
+ _dict['path_group'] = self.path_group.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoring from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "enabled": obj.get("enabled") if obj.get("enabled") is not None else False,
+ "failure_condition": obj.get("failure_condition"),
+ "path_group": HaConfigurationsGroupMonitoringPathMonitoringPathGroup.from_dict(obj["path_group"]) if obj.get("path_group") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group.py b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group.py
new file mode 100644
index 00000000..0e41d858
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMonitoringPathMonitoringPathGroup(BaseModel):
+ """
+ HaConfigurationsGroupMonitoringPathMonitoringPathGroup
+ """ # noqa: E501
+ logical_router: Optional[List[HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner]] = Field(default=None, description="Logical router")
+ __properties: ClassVar[List[str]] = ["logical_router"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroup from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in logical_router (list)
+ _items = []
+ if self.logical_router:
+ for _item_logical_router in self.logical_router:
+ if _item_logical_router:
+ _items.append(_item_logical_router.to_dict())
+ _dict['logical_router'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroup from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "logical_router": [HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner.from_dict(_item) for _item in obj["logical_router"]] if obj.get("logical_router") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner.py b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner.py
new file mode 100644
index 00000000..d41f90c2
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner.py
@@ -0,0 +1,117 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner import HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner(BaseModel):
+ """
+ HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner
+ """ # noqa: E501
+ destination_ip_group: Optional[List[HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner]] = None
+ enabled: Optional[StrictBool] = Field(default=True, description="Enable path group?")
+ failure_condition: Optional[StrictStr] = Field(default=None, description="Failure condition")
+ name: StrictStr = Field(description="Logical router name")
+ ping_count: Optional[Annotated[int, Field(le=10, strict=True, ge=3)]] = Field(default=10, description="Ping count")
+ ping_interval: Optional[Annotated[int, Field(le=60000, strict=True, ge=200)]] = Field(default=200, description="Ping interval")
+ __properties: ClassVar[List[str]] = ["destination_ip_group", "enabled", "failure_condition", "name", "ping_count", "ping_interval"]
+
+ @field_validator('failure_condition')
+ def failure_condition_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['any', 'all']):
+ raise ValueError("must be one of enum values ('any', 'all')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in destination_ip_group (list)
+ _items = []
+ if self.destination_ip_group:
+ for _item_destination_ip_group in self.destination_ip_group:
+ if _item_destination_ip_group:
+ _items.append(_item_destination_ip_group.to_dict())
+ _dict['destination_ip_group'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "destination_ip_group": [HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner.from_dict(_item) for _item in obj["destination_ip_group"]] if obj.get("destination_ip_group") is not None else None,
+ "enabled": obj.get("enabled") if obj.get("enabled") is not None else True,
+ "failure_condition": obj.get("failure_condition"),
+ "name": obj.get("name"),
+ "ping_count": obj.get("ping_count") if obj.get("ping_count") is not None else 10,
+ "ping_interval": obj.get("ping_interval") if obj.get("ping_interval") is not None else 200
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner.py b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner.py
new file mode 100644
index 00000000..b3921db5
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_monitoring_path_monitoring_path_group_logical_router_inner_destination_ip_group_inner.py
@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner(BaseModel):
+ """
+ HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner
+ """ # noqa: E501
+ destination_ip: Optional[List[StrictStr]] = Field(default=None, description="Destination IP addresses")
+ enabled: Optional[StrictBool] = Field(default=None, description="Enable destination IP group?")
+ failure_condition: Optional[StrictStr] = Field(default=None, description="Failure condition")
+ name: StrictStr = Field(description="Destination IP group name")
+ __properties: ClassVar[List[str]] = ["destination_ip", "enabled", "failure_condition", "name"]
+
+ @field_validator('failure_condition')
+ def failure_condition_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['any', 'all']):
+ raise ValueError("must be one of enum values ('any', 'all')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupMonitoringPathMonitoringPathGroupLogicalRouterInnerDestinationIpGroupInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "destination_ip": obj.get("destination_ip"),
+ "enabled": obj.get("enabled"),
+ "failure_condition": obj.get("failure_condition"),
+ "name": obj.get("name")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_state_synchronization.py b/scm/device_settings/models/ha_configurations_group_state_synchronization.py
new file mode 100644
index 00000000..b7d623a3
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_state_synchronization.py
@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_configurations_group_state_synchronization_ha2_keep_alive import HaConfigurationsGroupStateSynchronizationHa2KeepAlive
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupStateSynchronization(BaseModel):
+ """
+ HaConfigurationsGroupStateSynchronization
+ """ # noqa: E501
+ enabled: Optional[StrictBool] = Field(default=None, description="Enable session synchronization")
+ ha2_keep_alive: Optional[HaConfigurationsGroupStateSynchronizationHa2KeepAlive] = None
+ transport: Optional[StrictStr] = Field(default=None, description="Session synchronization transport")
+ __properties: ClassVar[List[str]] = ["enabled", "ha2_keep_alive", "transport"]
+
+ @field_validator('transport')
+ def transport_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['ethernet', 'ip', 'udp']):
+ raise ValueError("must be one of enum values ('ethernet', 'ip', 'udp')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupStateSynchronization from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of ha2_keep_alive
+ if self.ha2_keep_alive:
+ _dict['ha2_keep_alive'] = self.ha2_keep_alive.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupStateSynchronization from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "enabled": obj.get("enabled"),
+ "ha2_keep_alive": HaConfigurationsGroupStateSynchronizationHa2KeepAlive.from_dict(obj["ha2_keep_alive"]) if obj.get("ha2_keep_alive") is not None else None,
+ "transport": obj.get("transport")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_group_state_synchronization_ha2_keep_alive.py b/scm/device_settings/models/ha_configurations_group_state_synchronization_ha2_keep_alive.py
new file mode 100644
index 00000000..06bc1971
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_group_state_synchronization_ha2_keep_alive.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsGroupStateSynchronizationHa2KeepAlive(BaseModel):
+ """
+ HaConfigurationsGroupStateSynchronizationHa2KeepAlive
+ """ # noqa: E501
+ action: Optional[StrictStr] = Field(default=None, description="Keep-alive action")
+ enabled: Optional[StrictBool] = Field(default=False, description="Enable HA2 keep-alives?")
+ threshold: Optional[Annotated[int, Field(le=60000, strict=True, ge=5000)]] = Field(default=10000, description="Keep-alive threshold (milliseconds)")
+ __properties: ClassVar[List[str]] = ["action", "enabled", "threshold"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['log-only', 'split-datapath']):
+ raise ValueError("must be one of enum values ('log-only', 'split-datapath')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupStateSynchronizationHa2KeepAlive from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsGroupStateSynchronizationHa2KeepAlive from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "enabled": obj.get("enabled") if obj.get("enabled") is not None else False,
+ "threshold": obj.get("threshold") if obj.get("threshold") is not None else 10000
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_interface.py b/scm/device_settings/models/ha_configurations_interface.py
new file mode 100644
index 00000000..0f811f61
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_interface.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_configurations_interface_ha1 import HaConfigurationsInterfaceHa1
+from scm.device_settings.models.ha_configurations_interface_ha1_backup import HaConfigurationsInterfaceHa1Backup
+from scm.device_settings.models.ha_configurations_interface_ha2 import HaConfigurationsInterfaceHa2
+from scm.device_settings.models.ha_configurations_interface_ha2_backup import HaConfigurationsInterfaceHa2Backup
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsInterface(BaseModel):
+ """
+ HaConfigurationsInterface
+ """ # noqa: E501
+ ha1: HaConfigurationsInterfaceHa1
+ ha1_backup: Optional[HaConfigurationsInterfaceHa1Backup] = None
+ ha2: HaConfigurationsInterfaceHa2
+ ha2_backup: Optional[HaConfigurationsInterfaceHa2Backup] = None
+ __properties: ClassVar[List[str]] = ["ha1", "ha1_backup", "ha2", "ha2_backup"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterface from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of ha1
+ if self.ha1:
+ _dict['ha1'] = self.ha1.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of ha1_backup
+ if self.ha1_backup:
+ _dict['ha1_backup'] = self.ha1_backup.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of ha2
+ if self.ha2:
+ _dict['ha2'] = self.ha2.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of ha2_backup
+ if self.ha2_backup:
+ _dict['ha2_backup'] = self.ha2_backup.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterface from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ha1": HaConfigurationsInterfaceHa1.from_dict(obj["ha1"]) if obj.get("ha1") is not None else None,
+ "ha1_backup": HaConfigurationsInterfaceHa1Backup.from_dict(obj["ha1_backup"]) if obj.get("ha1_backup") is not None else None,
+ "ha2": HaConfigurationsInterfaceHa2.from_dict(obj["ha2"]) if obj.get("ha2") is not None else None,
+ "ha2_backup": HaConfigurationsInterfaceHa2Backup.from_dict(obj["ha2_backup"]) if obj.get("ha2_backup") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_interface_ha1.py b/scm/device_settings/models/ha_configurations_interface_ha1.py
new file mode 100644
index 00000000..ea871732
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_interface_ha1.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsInterfaceHa1(BaseModel):
+ """
+ HaConfigurationsInterfaceHa1
+ """ # noqa: E501
+ gateway: Optional[StrictStr] = Field(default=None, description="HA1 default gateway")
+ ip_address: Optional[StrictStr] = Field(default=None, description="HA1 IP address")
+ monitor_hold_time: Annotated[int, Field(le=60000, strict=True, ge=1000)] = Field(description="HA1 monitor hold time")
+ netmask: Optional[StrictStr] = Field(default=None, description="HA1 netmask")
+ port: StrictStr = Field(description="HA1 port")
+ __properties: ClassVar[List[str]] = ["gateway", "ip_address", "monitor_hold_time", "netmask", "port"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa1 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa1 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "gateway": obj.get("gateway"),
+ "ip_address": obj.get("ip_address"),
+ "monitor_hold_time": obj.get("monitor_hold_time") if obj.get("monitor_hold_time") is not None else 3000,
+ "netmask": obj.get("netmask"),
+ "port": obj.get("port")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_interface_ha1_backup.py b/scm/device_settings/models/ha_configurations_interface_ha1_backup.py
new file mode 100644
index 00000000..8e7e9812
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_interface_ha1_backup.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsInterfaceHa1Backup(BaseModel):
+ """
+ HaConfigurationsInterfaceHa1Backup
+ """ # noqa: E501
+ gateway: Optional[StrictStr] = Field(default=None, description="HA1 backup default gateway")
+ ip_address: Optional[StrictStr] = Field(default=None, description="HA1 backup IP address")
+ netmask: Optional[StrictStr] = Field(default=None, description="HA1 backup netmask")
+ port: Optional[StrictStr] = Field(default=None, description="HA1 backup port")
+ __properties: ClassVar[List[str]] = ["gateway", "ip_address", "netmask", "port"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa1Backup from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa1Backup from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "gateway": obj.get("gateway"),
+ "ip_address": obj.get("ip_address"),
+ "netmask": obj.get("netmask"),
+ "port": obj.get("port")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_interface_ha2.py b/scm/device_settings/models/ha_configurations_interface_ha2.py
new file mode 100644
index 00000000..0c6fa75a
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_interface_ha2.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsInterfaceHa2(BaseModel):
+ """
+ HaConfigurationsInterfaceHa2
+ """ # noqa: E501
+ gateway: Optional[StrictStr] = Field(default=None, description="HA2 default gateway")
+ ip_address: StrictStr = Field(description="HA2 IP address")
+ netmask: StrictStr = Field(description="HA2 netmask")
+ port: StrictStr = Field(description="HA2 port")
+ __properties: ClassVar[List[str]] = ["gateway", "ip_address", "netmask", "port"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa2 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa2 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "gateway": obj.get("gateway"),
+ "ip_address": obj.get("ip_address"),
+ "netmask": obj.get("netmask"),
+ "port": obj.get("port")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_configurations_interface_ha2_backup.py b/scm/device_settings/models/ha_configurations_interface_ha2_backup.py
new file mode 100644
index 00000000..6a5e8d9f
--- /dev/null
+++ b/scm/device_settings/models/ha_configurations_interface_ha2_backup.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaConfigurationsInterfaceHa2Backup(BaseModel):
+ """
+ HaConfigurationsInterfaceHa2Backup
+ """ # noqa: E501
+ gateway: Optional[StrictStr] = Field(default=None, description="HA2 backup default gateway")
+ ip_address: Optional[StrictStr] = Field(default=None, description="HA2 backup IP address")
+ netmask: Optional[StrictStr] = Field(default=None, description="HA2 backup netmask")
+ port: Optional[StrictStr] = Field(default=None, description="HA2 backup port")
+ __properties: ClassVar[List[str]] = ["gateway", "ip_address", "netmask", "port"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa2Backup from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaConfigurationsInterfaceHa2Backup from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "gateway": obj.get("gateway"),
+ "ip_address": obj.get("ip_address"),
+ "netmask": obj.get("netmask"),
+ "port": obj.get("port")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_devices.py b/scm/device_settings/models/ha_devices.py
new file mode 100644
index 00000000..5b375bc9
--- /dev/null
+++ b/scm/device_settings/models/ha_devices.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.ha_devices_ha_devices_inner import HaDevicesHaDevicesInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaDevices(BaseModel):
+ """
+ HaDevices
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ ha_devices: Optional[List[HaDevicesHaDevicesInner]] = Field(default=None, description="HA devices", alias="ha-devices")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "ha-devices", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaDevices from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in ha_devices (list)
+ _items = []
+ if self.ha_devices:
+ for _item_ha_devices in self.ha_devices:
+ if _item_ha_devices:
+ _items.append(_item_ha_devices.to_dict())
+ _dict['ha-devices'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaDevices from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "ha-devices": [HaDevicesHaDevicesInner.from_dict(_item) for _item in obj["ha-devices"]] if obj.get("ha-devices") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/ha_devices_ha_devices_inner.py b/scm/device_settings/models/ha_devices_ha_devices_inner.py
new file mode 100644
index 00000000..5d17d852
--- /dev/null
+++ b/scm/device_settings/models/ha_devices_ha_devices_inner.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class HaDevicesHaDevicesInner(BaseModel):
+ """
+ HaDevicesHaDevicesInner
+ """ # noqa: E501
+ primary_device_name: Optional[StrictStr] = Field(default=None, description="Primary device name")
+ primary_serial_number: Optional[StrictStr] = Field(default=None, description="Primary device serial number")
+ secondary_device_name: Optional[StrictStr] = Field(default=None, description="Secondary device name")
+ secondary_serial_number: Optional[StrictStr] = Field(default=None, description="Secondary device serial number")
+ __properties: ClassVar[List[str]] = ["primary_device_name", "primary_serial_number", "secondary_device_name", "secondary_serial_number"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of HaDevicesHaDevicesInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of HaDevicesHaDevicesInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "primary_device_name": obj.get("primary_device_name"),
+ "primary_serial_number": obj.get("primary_serial_number"),
+ "secondary_device_name": obj.get("secondary_device_name"),
+ "secondary_serial_number": obj.get("secondary_serial_number")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/list_ha_devices200_response.py b/scm/device_settings/models/list_ha_devices200_response.py
new file mode 100644
index 00000000..a4d842e5
--- /dev/null
+++ b/scm/device_settings/models/list_ha_devices200_response.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.ha_devices import HaDevices
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ListHADevices200Response(BaseModel):
+ """
+ ListHADevices200Response
+ """ # noqa: E501
+ data: Optional[List[HaDevices]] = None
+ __properties: ClassVar[List[str]] = ["data"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ListHADevices200Response from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ListHADevices200Response from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "data": [HaDevices.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/management_interface.py b/scm/device_settings/models/management_interface.py
new file mode 100644
index 00000000..5b5bdf4f
--- /dev/null
+++ b/scm/device_settings/models/management_interface.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.management_interface_management_interface import ManagementInterfaceManagementInterface
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagementInterface(BaseModel):
+ """
+ ManagementInterface
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ management_interface: Optional[ManagementInterfaceManagementInterface] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "management_interface", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ManagementInterface from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of management_interface
+ if self.management_interface:
+ _dict['management_interface'] = self.management_interface.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ManagementInterface from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "management_interface": ManagementInterfaceManagementInterface.from_dict(obj["management_interface"]) if obj.get("management_interface") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/management_interface_management_interface.py b/scm/device_settings/models/management_interface_management_interface.py
new file mode 100644
index 00000000..58e36812
--- /dev/null
+++ b/scm/device_settings/models/management_interface_management_interface.py
@@ -0,0 +1,128 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.management_interface_management_interface_mgmt_type import ManagementInterfaceManagementInterfaceMgmtType
+from scm.device_settings.models.management_interface_management_interface_permitted_ip_inner import ManagementInterfaceManagementInterfacePermittedIpInner
+from scm.device_settings.models.management_interface_management_interface_service import ManagementInterfaceManagementInterfaceService
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagementInterfaceManagementInterface(BaseModel):
+ """
+ ManagementInterfaceManagementInterface
+ """ # noqa: E501
+ default_gateway: Optional[StrictStr] = Field(default=None, description="Default gateway")
+ ip_address: Optional[StrictStr] = Field(default=None, description="IP address")
+ mgmt_type: Optional[ManagementInterfaceManagementInterfaceMgmtType] = None
+ mtu: Optional[StrictInt] = Field(default=1500, description="MTU")
+ netmask: Optional[StrictStr] = Field(default=None, description="Netmask")
+ permitted_ip: Optional[List[ManagementInterfaceManagementInterfacePermittedIpInner]] = Field(default=None, description="Permitting IP addresses")
+ service: Optional[ManagementInterfaceManagementInterfaceService] = None
+ speed_duplex: Optional[StrictStr] = Field(default='auto-negotiate', description="Speed and duplex")
+ __properties: ClassVar[List[str]] = ["default_gateway", "ip_address", "mgmt_type", "mtu", "netmask", "permitted_ip", "service", "speed_duplex"]
+
+ @field_validator('speed_duplex')
+ def speed_duplex_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['auto-negotiate', '10Mbps-half-duplex', '10Mbps-full-duplex', '100Mbps-half-duplex', '100Mbps-full-duplex', '1Gbps-half-duplex', '1Gbps-full-duplex']):
+ raise ValueError("must be one of enum values ('auto-negotiate', '10Mbps-half-duplex', '10Mbps-full-duplex', '100Mbps-half-duplex', '100Mbps-full-duplex', '1Gbps-half-duplex', '1Gbps-full-duplex')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterface from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of mgmt_type
+ if self.mgmt_type:
+ _dict['mgmt_type'] = self.mgmt_type.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of each item in permitted_ip (list)
+ _items = []
+ if self.permitted_ip:
+ for _item_permitted_ip in self.permitted_ip:
+ if _item_permitted_ip:
+ _items.append(_item_permitted_ip.to_dict())
+ _dict['permitted_ip'] = _items
+ # override the default output from pydantic by calling `to_dict()` of service
+ if self.service:
+ _dict['service'] = self.service.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterface from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "default_gateway": obj.get("default_gateway"),
+ "ip_address": obj.get("ip_address"),
+ "mgmt_type": ManagementInterfaceManagementInterfaceMgmtType.from_dict(obj["mgmt_type"]) if obj.get("mgmt_type") is not None else None,
+ "mtu": obj.get("mtu") if obj.get("mtu") is not None else 1500,
+ "netmask": obj.get("netmask"),
+ "permitted_ip": [ManagementInterfaceManagementInterfacePermittedIpInner.from_dict(_item) for _item in obj["permitted_ip"]] if obj.get("permitted_ip") is not None else None,
+ "service": ManagementInterfaceManagementInterfaceService.from_dict(obj["service"]) if obj.get("service") is not None else None,
+ "speed_duplex": obj.get("speed_duplex") if obj.get("speed_duplex") is not None else 'auto-negotiate'
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/management_interface_management_interface_mgmt_type.py b/scm/device_settings/models/management_interface_management_interface_mgmt_type.py
new file mode 100644
index 00000000..487ec8a9
--- /dev/null
+++ b/scm/device_settings/models/management_interface_management_interface_mgmt_type.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.management_interface_management_interface_mgmt_type_dhcp_client import ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagementInterfaceManagementInterfaceMgmtType(BaseModel):
+ """
+ IP type
+ """ # noqa: E501
+ dhcp_client: Optional[ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient] = None
+ static: Optional[Dict[str, Any]] = None
+ __properties: ClassVar[List[str]] = ["dhcp_client", "static"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfaceMgmtType from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of dhcp_client
+ if self.dhcp_client:
+ _dict['dhcp_client'] = self.dhcp_client.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfaceMgmtType from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "dhcp_client": ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient.from_dict(obj["dhcp_client"]) if obj.get("dhcp_client") is not None else None,
+ "static": obj.get("static")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/management_interface_management_interface_mgmt_type_dhcp_client.py b/scm/device_settings/models/management_interface_management_interface_mgmt_type_dhcp_client.py
new file mode 100644
index 00000000..6cddaf57
--- /dev/null
+++ b/scm/device_settings/models/management_interface_management_interface_mgmt_type_dhcp_client.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient(BaseModel):
+ """
+ ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient
+ """ # noqa: E501
+ accept_dhcp_domain: Optional[StrictBool] = Field(default=False, description="Accept DHCP server provided domain name")
+ accept_dhcp_hostname: Optional[StrictBool] = Field(default=False, description="Accept DHCP server provided hostname")
+ send_client_id: Optional[StrictBool] = Field(default=False, description="Send client ID")
+ send_hostname: Optional[StrictBool] = Field(default=False, description="Send hostname")
+ __properties: ClassVar[List[str]] = ["accept_dhcp_domain", "accept_dhcp_hostname", "send_client_id", "send_hostname"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfaceMgmtTypeDhcpClient from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "accept_dhcp_domain": obj.get("accept_dhcp_domain") if obj.get("accept_dhcp_domain") is not None else False,
+ "accept_dhcp_hostname": obj.get("accept_dhcp_hostname") if obj.get("accept_dhcp_hostname") is not None else False,
+ "send_client_id": obj.get("send_client_id") if obj.get("send_client_id") is not None else False,
+ "send_hostname": obj.get("send_hostname") if obj.get("send_hostname") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/management_interface_management_interface_permitted_ip_inner.py b/scm/device_settings/models/management_interface_management_interface_permitted_ip_inner.py
new file mode 100644
index 00000000..35d94244
--- /dev/null
+++ b/scm/device_settings/models/management_interface_management_interface_permitted_ip_inner.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagementInterfaceManagementInterfacePermittedIpInner(BaseModel):
+ """
+ ManagementInterfaceManagementInterfacePermittedIpInner
+ """ # noqa: E501
+ description: Optional[StrictStr] = Field(default=None, description="Description")
+ name: Optional[StrictStr] = Field(default=None, description="IP address")
+ __properties: ClassVar[List[str]] = ["description", "name"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfacePermittedIpInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfacePermittedIpInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "description": obj.get("description"),
+ "name": obj.get("name")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/management_interface_management_interface_service.py b/scm/device_settings/models/management_interface_management_interface_service.py
new file mode 100644
index 00000000..20b4938d
--- /dev/null
+++ b/scm/device_settings/models/management_interface_management_interface_service.py
@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ManagementInterfaceManagementInterfaceService(BaseModel):
+ """
+ Network services
+ """ # noqa: E501
+ disable_http: Optional[StrictBool] = Field(default=False, description="HTTP")
+ disable_http_ocsp: Optional[StrictBool] = Field(default=False, description="HTTP OCSP")
+ disable_https: Optional[StrictBool] = Field(default=True, description="HTTPS")
+ disable_icmp: Optional[StrictBool] = Field(default=False, description="Ping")
+ disable_snmp: Optional[StrictBool] = Field(default=False, description="SNMP")
+ disable_ssh: Optional[StrictBool] = Field(default=True, description="SSH")
+ disable_telnet: Optional[StrictBool] = Field(default=False, description="Telnet")
+ disable_userid_service: Optional[StrictBool] = Field(default=False, description="User-ID")
+ disable_userid_syslog_listener_ssl: Optional[StrictBool] = Field(default=False, description="User-ID syslog listener over SSL")
+ disable_userid_syslog_listener_udp: Optional[StrictBool] = Field(default=False, description="User-ID syslog listener over UDP")
+ __properties: ClassVar[List[str]] = ["disable_http", "disable_http_ocsp", "disable_https", "disable_icmp", "disable_snmp", "disable_ssh", "disable_telnet", "disable_userid_service", "disable_userid_syslog_listener_ssl", "disable_userid_syslog_listener_udp"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfaceService from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ManagementInterfaceManagementInterfaceService from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "disable_http": obj.get("disable_http") if obj.get("disable_http") is not None else False,
+ "disable_http_ocsp": obj.get("disable_http_ocsp") if obj.get("disable_http_ocsp") is not None else False,
+ "disable_https": obj.get("disable_https") if obj.get("disable_https") is not None else True,
+ "disable_icmp": obj.get("disable_icmp") if obj.get("disable_icmp") is not None else False,
+ "disable_snmp": obj.get("disable_snmp") if obj.get("disable_snmp") is not None else False,
+ "disable_ssh": obj.get("disable_ssh") if obj.get("disable_ssh") is not None else True,
+ "disable_telnet": obj.get("disable_telnet") if obj.get("disable_telnet") is not None else False,
+ "disable_userid_service": obj.get("disable_userid_service") if obj.get("disable_userid_service") is not None else False,
+ "disable_userid_syslog_listener_ssl": obj.get("disable_userid_syslog_listener_ssl") if obj.get("disable_userid_syslog_listener_ssl") is not None else False,
+ "disable_userid_syslog_listener_udp": obj.get("disable_userid_syslog_listener_udp") if obj.get("disable_userid_syslog_listener_udp") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/motd_banner_settings.py b/scm/device_settings/models/motd_banner_settings.py
new file mode 100644
index 00000000..2626708a
--- /dev/null
+++ b/scm/device_settings/models/motd_banner_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.motd_banner_settings_motd_and_banner import MotdBannerSettingsMotdAndBanner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MotdBannerSettings(BaseModel):
+ """
+ MotdBannerSettings
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ motd_and_banner: Optional[MotdBannerSettingsMotdAndBanner] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "motd_and_banner", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MotdBannerSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of motd_and_banner
+ if self.motd_and_banner:
+ _dict['motd_and_banner'] = self.motd_and_banner.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MotdBannerSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "motd_and_banner": MotdBannerSettingsMotdAndBanner.from_dict(obj["motd_and_banner"]) if obj.get("motd_and_banner") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/motd_banner_settings_motd_and_banner.py b/scm/device_settings/models/motd_banner_settings_motd_and_banner.py
new file mode 100644
index 00000000..e32d8763
--- /dev/null
+++ b/scm/device_settings/models/motd_banner_settings_motd_and_banner.py
@@ -0,0 +1,123 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.motd_color import MotdColor
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MotdBannerSettingsMotdAndBanner(BaseModel):
+ """
+ MotdBannerSettingsMotdAndBanner
+ """ # noqa: E501
+ banner_footer: Optional[StrictStr] = None
+ banner_footer_color: Optional[MotdColor] = None
+ banner_footer_text_color: Optional[MotdColor] = None
+ banner_header: Optional[StrictStr] = None
+ banner_header_color: Optional[MotdColor] = None
+ banner_header_footer_match: Optional[StrictBool] = None
+ banner_header_text_color: Optional[MotdColor] = None
+ message: Optional[StrictStr] = None
+ motd_color: Optional[MotdColor] = None
+ motd_do_not_display_again: Optional[StrictBool] = None
+ motd_enable: Optional[StrictBool] = None
+ motd_title: Optional[StrictStr] = None
+ severity: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["banner_footer", "banner_footer_color", "banner_footer_text_color", "banner_header", "banner_header_color", "banner_header_footer_match", "banner_header_text_color", "message", "motd_color", "motd_do_not_display_again", "motd_enable", "motd_title", "severity"]
+
+ @field_validator('severity')
+ def severity_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['warning', 'question', 'error', 'info']):
+ raise ValueError("must be one of enum values ('warning', 'question', 'error', 'info')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MotdBannerSettingsMotdAndBanner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MotdBannerSettingsMotdAndBanner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "banner_footer": obj.get("banner_footer"),
+ "banner_footer_color": obj.get("banner_footer_color"),
+ "banner_footer_text_color": obj.get("banner_footer_text_color"),
+ "banner_header": obj.get("banner_header"),
+ "banner_header_color": obj.get("banner_header_color"),
+ "banner_header_footer_match": obj.get("banner_header_footer_match"),
+ "banner_header_text_color": obj.get("banner_header_text_color"),
+ "message": obj.get("message"),
+ "motd_color": obj.get("motd_color"),
+ "motd_do_not_display_again": obj.get("motd_do_not_display_again"),
+ "motd_enable": obj.get("motd_enable"),
+ "motd_title": obj.get("motd_title"),
+ "severity": obj.get("severity")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/motd_color.py b/scm/device_settings/models/motd_color.py
new file mode 100644
index 00000000..1e3dbcab
--- /dev/null
+++ b/scm/device_settings/models/motd_color.py
@@ -0,0 +1,53 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class MotdColor(str, Enum):
+ """
+ The following list details the supported values and their colors. - `color1` = Red - `color2` = Green - `color3` = Blue - `color4` = Yellow - `color5` = Copper - `color6` = Orange - `color7` = Purple - `color8` = Gray - `color9` = Light Green - `color10` = Cyan - `color11` = Light Gray - `color12` = Blue Gray - `color13` = Lime - `color14` = Black - `color15` = Gold - `color16` = Brown - `color17` = Olive
+ """
+
+ """
+ allowed enum values
+ """
+ COLOR1 = 'color1'
+ COLOR2 = 'color2'
+ COLOR3 = 'color3'
+ COLOR4 = 'color4'
+ COLOR5 = 'color5'
+ COLOR6 = 'color6'
+ COLOR7 = 'color7'
+ COLOR8 = 'color8'
+ COLOR9 = 'color9'
+ COLOR10 = 'color10'
+ COLOR11 = 'color11'
+ COLOR12 = 'color12'
+ COLOR13 = 'color13'
+ COLOR14 = 'color14'
+ COLOR15 = 'color15'
+ COLOR16 = 'color16'
+ COLOR17 = 'color17'
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Self:
+ """Create an instance of MotdColor from a JSON string"""
+ return cls(json.loads(json_str))
+
+
diff --git a/scm/device_settings/models/service_route.py b/scm/device_settings/models/service_route.py
new file mode 100644
index 00000000..3eac0da0
--- /dev/null
+++ b/scm/device_settings/models/service_route.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.service_route_route import ServiceRouteRoute
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceRoute(BaseModel):
+ """
+ ServiceRoute
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ route: Optional[ServiceRouteRoute] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "route", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceRoute from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of route
+ if self.route:
+ _dict['route'] = self.route.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceRoute from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "route": ServiceRouteRoute.from_dict(obj["route"]) if obj.get("route") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_route_route.py b/scm/device_settings/models/service_route_route.py
new file mode 100644
index 00000000..379f666b
--- /dev/null
+++ b/scm/device_settings/models/service_route_route.py
@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_route_route_destination_inner import ServiceRouteRouteDestinationInner
+from scm.device_settings.models.service_route_route_service_inner import ServiceRouteRouteServiceInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceRouteRoute(BaseModel):
+ """
+ ServiceRouteRoute
+ """ # noqa: E501
+ destination: Optional[List[ServiceRouteRouteDestinationInner]] = None
+ service: Optional[List[ServiceRouteRouteServiceInner]] = None
+ __properties: ClassVar[List[str]] = ["destination", "service"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceRouteRoute from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in destination (list)
+ _items = []
+ if self.destination:
+ for _item_destination in self.destination:
+ if _item_destination:
+ _items.append(_item_destination.to_dict())
+ _dict['destination'] = _items
+ # override the default output from pydantic by calling `to_dict()` of each item in service (list)
+ _items = []
+ if self.service:
+ for _item_service in self.service:
+ if _item_service:
+ _items.append(_item_service.to_dict())
+ _dict['service'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceRouteRoute from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "destination": [ServiceRouteRouteDestinationInner.from_dict(_item) for _item in obj["destination"]] if obj.get("destination") is not None else None,
+ "service": [ServiceRouteRouteServiceInner.from_dict(_item) for _item in obj["service"]] if obj.get("service") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_route_route_destination_inner.py b/scm/device_settings/models/service_route_route_destination_inner.py
new file mode 100644
index 00000000..6ff3adbd
--- /dev/null
+++ b/scm/device_settings/models/service_route_route_destination_inner.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_route_route_destination_inner_source import ServiceRouteRouteDestinationInnerSource
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceRouteRouteDestinationInner(BaseModel):
+ """
+ ServiceRouteRouteDestinationInner
+ """ # noqa: E501
+ name: Optional[StrictStr] = None
+ source: Optional[ServiceRouteRouteDestinationInnerSource] = None
+ __properties: ClassVar[List[str]] = ["name", "source"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteDestinationInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of source
+ if self.source:
+ _dict['source'] = self.source.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteDestinationInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "name": obj.get("name"),
+ "source": ServiceRouteRouteDestinationInnerSource.from_dict(obj["source"]) if obj.get("source") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_route_route_destination_inner_source.py b/scm/device_settings/models/service_route_route_destination_inner_source.py
new file mode 100644
index 00000000..3baa7c9c
--- /dev/null
+++ b/scm/device_settings/models/service_route_route_destination_inner_source.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceRouteRouteDestinationInnerSource(BaseModel):
+ """
+ ServiceRouteRouteDestinationInnerSource
+ """ # noqa: E501
+ address: Optional[StrictStr] = None
+ interface: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["address", "interface"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteDestinationInnerSource from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteDestinationInnerSource from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "address": obj.get("address"),
+ "interface": obj.get("interface")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_route_route_service_inner.py b/scm/device_settings/models/service_route_route_service_inner.py
new file mode 100644
index 00000000..5c1e8121
--- /dev/null
+++ b/scm/device_settings/models/service_route_route_service_inner.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_route_route_service_inner_source import ServiceRouteRouteServiceInnerSource
+from scm.device_settings.models.service_route_route_service_inner_source_v6 import ServiceRouteRouteServiceInnerSourceV6
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceRouteRouteServiceInner(BaseModel):
+ """
+ ServiceRouteRouteServiceInner
+ """ # noqa: E501
+ name: Optional[StrictStr] = Field(default=None, description="The follow list details the accepted `name` values and their corresponding service description. - `autofocus` = AutoFocus Cloud - `crl-status` = CRL servers - `data-services` = Data Services - `ddns` = DDNS server(s) - `deployments` = Panorama pushed updates - `dns` = DNS server(s) - `edl-updates` = External Dynamic List update server - `email` = SMTP gateway(s) - `hsm` = Hardware Security Module server(s) - `http` = HTTP Forwarding server(s) - `iot` = IOT service-route - `kerberos` = Kerberos server - `ldap` = LDAP server - `mdm` = MDM servers - `mfa` = Multi-Factor Authentication - `netflow` = Netflow server(s) - `ntp` = NTP server(s) - `paloalto-networks-services` = Palo Alto Networks Services - `panorama` = Panorama server - `panorama-log-forwarding` = Panorama Log Forwarding - `proxy` = Proxy server - `radius` = RADIUS server - `scep` = SCEP - `snmp` = SNMP server(s) - `syslog` = Syslog server(s) - `tacplus` = TACACS+ server - `uid-`agent = UID agent(s) - `url-`updates = URL update server - `vmmonitor` = VM monitor - `wildfire-`private = WildFire Appliance - `ztp` = ZTP and Auto-VPN DDNS ")
+ source: Optional[ServiceRouteRouteServiceInnerSource] = None
+ source_v6: Optional[ServiceRouteRouteServiceInnerSourceV6] = None
+ __properties: ClassVar[List[str]] = ["name", "source", "source_v6"]
+
+ @field_validator('name')
+ def name_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['autofocus', 'crl-status', 'data-services', 'ddns', 'deployments', 'dns', 'edl-updates', 'email', 'hsm', 'http', 'iot', 'kerberos', 'ldap', 'mdm', 'mfa', 'netflow', 'ntp', 'paloalto-networks-services', 'panorama', 'panorama-log-forwarding', 'proxy', 'radius', 'scep', 'snmp', 'syslog', 'tacplus', 'uid-agent', 'url-updates', 'vmmonitor', 'wildfire-private', 'ztp']):
+ raise ValueError("must be one of enum values ('autofocus', 'crl-status', 'data-services', 'ddns', 'deployments', 'dns', 'edl-updates', 'email', 'hsm', 'http', 'iot', 'kerberos', 'ldap', 'mdm', 'mfa', 'netflow', 'ntp', 'paloalto-networks-services', 'panorama', 'panorama-log-forwarding', 'proxy', 'radius', 'scep', 'snmp', 'syslog', 'tacplus', 'uid-agent', 'url-updates', 'vmmonitor', 'wildfire-private', 'ztp')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteServiceInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of source
+ if self.source:
+ _dict['source'] = self.source.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of source_v6
+ if self.source_v6:
+ _dict['source_v6'] = self.source_v6.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteServiceInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "name": obj.get("name"),
+ "source": ServiceRouteRouteServiceInnerSource.from_dict(obj["source"]) if obj.get("source") is not None else None,
+ "source_v6": ServiceRouteRouteServiceInnerSourceV6.from_dict(obj["source_v6"]) if obj.get("source_v6") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_route_route_service_inner_source.py b/scm/device_settings/models/service_route_route_service_inner_source.py
new file mode 100644
index 00000000..79b4f5ec
--- /dev/null
+++ b/scm/device_settings/models/service_route_route_service_inner_source.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceRouteRouteServiceInnerSource(BaseModel):
+ """
+ ServiceRouteRouteServiceInnerSource
+ """ # noqa: E501
+ address: Optional[StrictStr] = None
+ interface: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["address", "interface"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteServiceInnerSource from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteServiceInnerSource from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "address": obj.get("address"),
+ "interface": obj.get("interface")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_route_route_service_inner_source_v6.py b/scm/device_settings/models/service_route_route_service_inner_source_v6.py
new file mode 100644
index 00000000..3184a91e
--- /dev/null
+++ b/scm/device_settings/models/service_route_route_service_inner_source_v6.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceRouteRouteServiceInnerSourceV6(BaseModel):
+ """
+ ServiceRouteRouteServiceInnerSourceV6
+ """ # noqa: E501
+ address: Optional[StrictStr] = None
+ interface: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["address", "interface"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteServiceInnerSourceV6 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceRouteRouteServiceInnerSourceV6 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "address": obj.get("address"),
+ "interface": obj.get("interface")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings.py b/scm/device_settings/models/service_settings.py
new file mode 100644
index 00000000..cdbea0fc
--- /dev/null
+++ b/scm/device_settings/models/service_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.service_settings_services import ServiceSettingsServices
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettings(BaseModel):
+ """
+ ServiceSettings
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ services: Optional[ServiceSettingsServices] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "services", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of services
+ if self.services:
+ _dict['services'] = self.services.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "services": ServiceSettingsServices.from_dict(obj["services"]) if obj.get("services") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services.py b/scm/device_settings/models/service_settings_services.py
new file mode 100644
index 00000000..0396b8ee
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services.py
@@ -0,0 +1,118 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, SecretStr, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from scm.device_settings.models.service_settings_services_dns_setting import ServiceSettingsServicesDnsSetting
+from scm.device_settings.models.service_settings_services_ntp_servers import ServiceSettingsServicesNtpServers
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServices(BaseModel):
+ """
+ ServiceSettingsServices
+ """ # noqa: E501
+ dns_setting: Optional[ServiceSettingsServicesDnsSetting] = None
+ fqdn_refresh_time: Optional[Union[StrictFloat, StrictInt]] = 15
+ fqdn_stale_entry_timeout: Optional[Union[StrictFloat, StrictInt]] = 1440
+ inline_cloud_proxy: Optional[StrictBool] = False
+ lcaas_use_proxy: Optional[StrictBool] = False
+ ntp_servers: Optional[ServiceSettingsServicesNtpServers] = None
+ secure_proxy_password: Optional[SecretStr] = None
+ secure_proxy_port: Optional[Union[StrictFloat, StrictInt]] = None
+ secure_proxy_server: Optional[StrictStr] = None
+ secure_proxy_user: Optional[StrictStr] = None
+ server_verification: Optional[StrictBool] = True
+ update_server: Optional[StrictStr] = 'updates.paloaltonetworks.com'
+ __properties: ClassVar[List[str]] = ["dns_setting", "fqdn_refresh_time", "fqdn_stale_entry_timeout", "inline_cloud_proxy", "lcaas_use_proxy", "ntp_servers", "secure_proxy_password", "secure_proxy_port", "secure_proxy_server", "secure_proxy_user", "server_verification", "update_server"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServices from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of dns_setting
+ if self.dns_setting:
+ _dict['dns_setting'] = self.dns_setting.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of ntp_servers
+ if self.ntp_servers:
+ _dict['ntp_servers'] = self.ntp_servers.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServices from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "dns_setting": ServiceSettingsServicesDnsSetting.from_dict(obj["dns_setting"]) if obj.get("dns_setting") is not None else None,
+ "fqdn_refresh_time": obj.get("fqdn_refresh_time") if obj.get("fqdn_refresh_time") is not None else 15,
+ "fqdn_stale_entry_timeout": obj.get("fqdn_stale_entry_timeout") if obj.get("fqdn_stale_entry_timeout") is not None else 1440,
+ "inline_cloud_proxy": obj.get("inline_cloud_proxy") if obj.get("inline_cloud_proxy") is not None else False,
+ "lcaas_use_proxy": obj.get("lcaas_use_proxy") if obj.get("lcaas_use_proxy") is not None else False,
+ "ntp_servers": ServiceSettingsServicesNtpServers.from_dict(obj["ntp_servers"]) if obj.get("ntp_servers") is not None else None,
+ "secure_proxy_password": obj.get("secure_proxy_password"),
+ "secure_proxy_port": obj.get("secure_proxy_port"),
+ "secure_proxy_server": obj.get("secure_proxy_server"),
+ "secure_proxy_user": obj.get("secure_proxy_user"),
+ "server_verification": obj.get("server_verification") if obj.get("server_verification") is not None else True,
+ "update_server": obj.get("update_server") if obj.get("update_server") is not None else 'updates.paloaltonetworks.com'
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_dns_setting.py b/scm/device_settings/models/service_settings_services_dns_setting.py
new file mode 100644
index 00000000..bb13f424
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_dns_setting.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_settings_services_dns_setting_servers import ServiceSettingsServicesDnsSettingServers
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesDnsSetting(BaseModel):
+ """
+ ServiceSettingsServicesDnsSetting
+ """ # noqa: E501
+ dns_proxy_object: Optional[StrictStr] = None
+ servers: Optional[ServiceSettingsServicesDnsSettingServers] = None
+ __properties: ClassVar[List[str]] = ["dns_proxy_object", "servers"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesDnsSetting from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of servers
+ if self.servers:
+ _dict['servers'] = self.servers.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesDnsSetting from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "dns_proxy_object": obj.get("dns_proxy_object"),
+ "servers": ServiceSettingsServicesDnsSettingServers.from_dict(obj["servers"]) if obj.get("servers") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_dns_setting_servers.py b/scm/device_settings/models/service_settings_services_dns_setting_servers.py
new file mode 100644
index 00000000..49cf0fe4
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_dns_setting_servers.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesDnsSettingServers(BaseModel):
+ """
+ ServiceSettingsServicesDnsSettingServers
+ """ # noqa: E501
+ primary: Optional[StrictStr] = None
+ secondary: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["primary", "secondary"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesDnsSettingServers from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesDnsSettingServers from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "primary": obj.get("primary"),
+ "secondary": obj.get("secondary")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_ntp_servers.py b/scm/device_settings/models/service_settings_services_ntp_servers.py
new file mode 100644
index 00000000..7afe1af9
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_ntp_servers.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server import ServiceSettingsServicesNtpServersPrimaryNtpServer
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesNtpServers(BaseModel):
+ """
+ ServiceSettingsServicesNtpServers
+ """ # noqa: E501
+ primary_ntp_server: Optional[ServiceSettingsServicesNtpServersPrimaryNtpServer] = None
+ secondary_ntp_server: Optional[ServiceSettingsServicesNtpServersPrimaryNtpServer] = None
+ __properties: ClassVar[List[str]] = ["primary_ntp_server", "secondary_ntp_server"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServers from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of primary_ntp_server
+ if self.primary_ntp_server:
+ _dict['primary_ntp_server'] = self.primary_ntp_server.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of secondary_ntp_server
+ if self.secondary_ntp_server:
+ _dict['secondary_ntp_server'] = self.secondary_ntp_server.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServers from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "primary_ntp_server": ServiceSettingsServicesNtpServersPrimaryNtpServer.from_dict(obj["primary_ntp_server"]) if obj.get("primary_ntp_server") is not None else None,
+ "secondary_ntp_server": ServiceSettingsServicesNtpServersPrimaryNtpServer.from_dict(obj["secondary_ntp_server"]) if obj.get("secondary_ntp_server") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server.py b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server.py
new file mode 100644
index 00000000..11a4b6d8
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesNtpServersPrimaryNtpServer(BaseModel):
+ """
+ ServiceSettingsServicesNtpServersPrimaryNtpServer
+ """ # noqa: E501
+ authentication_type: Optional[ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType] = None
+ ntp_server_address: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["authentication_type", "ntp_server_address"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServer from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of authentication_type
+ if self.authentication_type:
+ _dict['authentication_type'] = self.authentication_type.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServer from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authentication_type": ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType.from_dict(obj["authentication_type"]) if obj.get("authentication_type") is not None else None,
+ "ntp_server_address": obj.get("ntp_server_address")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type.py b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type.py
new file mode 100644
index 00000000..c69369dd
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type.py
@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType(BaseModel):
+ """
+ ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType
+ """ # noqa: E501
+ autokey: Optional[Dict[str, Any]] = None
+ var_none: Optional[Dict[str, Any]] = Field(default=None, alias="none")
+ symmetric_key: Optional[ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey] = None
+ __properties: ClassVar[List[str]] = ["autokey", "none", "symmetric_key"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of symmetric_key
+ if self.symmetric_key:
+ _dict['symmetric_key'] = self.symmetric_key.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationType from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "autokey": obj.get("autokey"),
+ "none": obj.get("none"),
+ "symmetric_key": ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey.from_dict(obj["symmetric_key"]) if obj.get("symmetric_key") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key.py b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key.py
new file mode 100644
index 00000000..b093a71e
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey(BaseModel):
+ """
+ ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey
+ """ # noqa: E501
+ algorithm: Optional[ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm] = None
+ key_id: Optional[Union[StrictFloat, StrictInt]] = None
+ __properties: ClassVar[List[str]] = ["algorithm", "key_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of algorithm
+ if self.algorithm:
+ _dict['algorithm'] = self.algorithm.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKey from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "algorithm": ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm.from_dict(obj["algorithm"]) if obj.get("algorithm") is not None else None,
+ "key_id": obj.get("key_id")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm.py b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm.py
new file mode 100644
index 00000000..393071ce
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5 import ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm(BaseModel):
+ """
+ ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm
+ """ # noqa: E501
+ md5: Optional[ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5] = None
+ sha1: Optional[ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5] = None
+ __properties: ClassVar[List[str]] = ["md5", "sha1"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of md5
+ if self.md5:
+ _dict['md5'] = self.md5.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of sha1
+ if self.sha1:
+ _dict['sha1'] = self.sha1.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithm from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "md5": ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.from_dict(obj["md5"]) if obj.get("md5") is not None else None,
+ "sha1": ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5.from_dict(obj["sha1"]) if obj.get("sha1") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5.py b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5.py
new file mode 100644
index 00000000..f2d5f01c
--- /dev/null
+++ b/scm/device_settings/models/service_settings_services_ntp_servers_primary_ntp_server_authentication_type_symmetric_key_algorithm_md5.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, SecretStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5(BaseModel):
+ """
+ ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5
+ """ # noqa: E501
+ authentication_key: Optional[SecretStr] = None
+ __properties: ClassVar[List[str]] = ["authentication_key"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ServiceSettingsServicesNtpServersPrimaryNtpServerAuthenticationTypeSymmetricKeyAlgorithmMd5 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authentication_key": obj.get("authentication_key")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_settings.py b/scm/device_settings/models/session_settings.py
new file mode 100644
index 00000000..f337388e
--- /dev/null
+++ b/scm/device_settings/models/session_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.session_settings_session_settings import SessionSettingsSessionSettings
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionSettings(BaseModel):
+ """
+ SessionSettings
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ session_settings: Optional[SessionSettingsSessionSettings] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "session_settings", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of session_settings
+ if self.session_settings:
+ _dict['session_settings'] = self.session_settings.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "session_settings": SessionSettingsSessionSettings.from_dict(obj["session_settings"]) if obj.get("session_settings") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_settings_session_settings.py b/scm/device_settings/models/session_settings_session_settings.py
new file mode 100644
index 00000000..02ac2309
--- /dev/null
+++ b/scm/device_settings/models/session_settings_session_settings.py
@@ -0,0 +1,159 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from scm.device_settings.models.session_settings_session_settings_config import SessionSettingsSessionSettingsConfig
+from scm.device_settings.models.session_settings_session_settings_icmpv6_rate_limit import SessionSettingsSessionSettingsIcmpv6RateLimit
+from scm.device_settings.models.session_settings_session_settings_jumbo_frame import SessionSettingsSessionSettingsJumboFrame
+from scm.device_settings.models.session_settings_session_settings_nat import SessionSettingsSessionSettingsNat
+from scm.device_settings.models.session_settings_session_settings_nat64 import SessionSettingsSessionSettingsNat64
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionSettingsSessionSettings(BaseModel):
+ """
+ SessionSettingsSessionSettings
+ """ # noqa: E501
+ accelerated_aging_enable: Optional[StrictBool] = Field(default=True, description="Enable accelerated aging")
+ accelerated_aging_scaling_factor: Optional[Union[Annotated[float, Field(le=16, strict=True, ge=2)], Annotated[int, Field(le=16, strict=True, ge=2)]]] = Field(default=2, description="Accelerated aging scaling factor")
+ accelerated_aging_threshold: Optional[Union[Annotated[float, Field(le=99, strict=True, ge=50)], Annotated[int, Field(le=99, strict=True, ge=50)]]] = Field(default=80, description="Accelerated aging threshold")
+ config: Optional[SessionSettingsSessionSettingsConfig] = None
+ dhcp_bcast_session_on: Optional[StrictBool] = Field(default=False, description="Enable DHCP broadcast session")
+ erspan: Optional[StrictBool] = Field(default=False, description="Enable ERSPAN support")
+ icmp_unreachable_rate: Optional[Union[Annotated[float, Field(le=65535, strict=True, ge=1)], Annotated[int, Field(le=65535, strict=True, ge=1)]]] = Field(default=200, description="ICMP unreachable packet rate (per second)")
+ icmpv6_rate_limit: Optional[SessionSettingsSessionSettingsIcmpv6RateLimit] = None
+ ipv6_firewalling: Optional[StrictBool] = Field(default=True, description="Enable IPv6 firewalling")
+ jumbo_frame: Optional[SessionSettingsSessionSettingsJumboFrame] = None
+ max_pending_mcast_pkts_per_session: Optional[Union[Annotated[float, Field(le=2000, strict=True, ge=1)], Annotated[int, Field(le=2000, strict=True, ge=1)]]] = Field(default=1000, description="Multicast route setup buffer size")
+ multicast_route_setup_buffering: Optional[StrictBool] = Field(default=False, description="Multicast route setup buffering")
+ nat: Optional[SessionSettingsSessionSettingsNat] = None
+ nat64: Optional[SessionSettingsSessionSettingsNat64] = None
+ packet_buffer_protection_activate: Optional[Union[Annotated[float, Field(le=99, strict=True, ge=0)], Annotated[int, Field(le=99, strict=True, ge=0)]]] = Field(default=80, description="Activate (%)")
+ packet_buffer_protection_alert: Optional[Annotated[int, Field(le=99, strict=True, ge=0)]] = Field(default=50, description="Alert (%)")
+ packet_buffer_protection_block_countdown: Optional[Union[Annotated[float, Field(le=99, strict=True, ge=0)], Annotated[int, Field(le=99, strict=True, ge=0)]]] = Field(default=80, description="Block countdown threshold (%)")
+ packet_buffer_protection_block_duration_time: Optional[Union[Annotated[float, Field(le=15999999, strict=True, ge=1)], Annotated[int, Field(le=15999999, strict=True, ge=1)]]] = Field(default=3600, description="Block duration (seconds)")
+ packet_buffer_protection_block_hold_time: Optional[Union[Annotated[float, Field(le=65535, strict=True, ge=0)], Annotated[int, Field(le=65535, strict=True, ge=0)]]] = Field(default=60, description="Block hold time (seconds)")
+ packet_buffer_protection_enable: Optional[StrictBool] = Field(default=True, description="Enable packet buffer protection")
+ packet_buffer_protection_latency_activate: Optional[Union[Annotated[float, Field(le=20000, strict=True, ge=1)], Annotated[int, Field(le=20000, strict=True, ge=1)]]] = Field(default=200, description="Latency activate (milliseconds)")
+ packet_buffer_protection_latency_alert: Optional[Union[Annotated[float, Field(le=20000, strict=True, ge=1)], Annotated[int, Field(le=20000, strict=True, ge=1)]]] = Field(default=50, description="Latency alert (milliseconds)")
+ packet_buffer_protection_latency_block_countdown: Optional[Union[Annotated[float, Field(le=20000, strict=True, ge=1)], Annotated[int, Field(le=20000, strict=True, ge=1)]]] = Field(default=500, description="Block countdown threshold (milliseconds)")
+ packet_buffer_protection_latency_max_tolerate: Optional[Union[Annotated[float, Field(le=20000, strict=True, ge=1)], Annotated[int, Field(le=20000, strict=True, ge=1)]]] = Field(default=500, description="Latency max tolerate (milliseconds)")
+ packet_buffer_protection_monitor_only: Optional[StrictBool] = Field(default=False, description="Packet buffer protection monitor only")
+ packet_buffer_protection_use_latency: Optional[StrictBool] = Field(default=False, description="Enabled latency-based activation")
+ __properties: ClassVar[List[str]] = ["accelerated_aging_enable", "accelerated_aging_scaling_factor", "accelerated_aging_threshold", "config", "dhcp_bcast_session_on", "erspan", "icmp_unreachable_rate", "icmpv6_rate_limit", "ipv6_firewalling", "jumbo_frame", "max_pending_mcast_pkts_per_session", "multicast_route_setup_buffering", "nat", "nat64", "packet_buffer_protection_activate", "packet_buffer_protection_alert", "packet_buffer_protection_block_countdown", "packet_buffer_protection_block_duration_time", "packet_buffer_protection_block_hold_time", "packet_buffer_protection_enable", "packet_buffer_protection_latency_activate", "packet_buffer_protection_latency_alert", "packet_buffer_protection_latency_block_countdown", "packet_buffer_protection_latency_max_tolerate", "packet_buffer_protection_monitor_only", "packet_buffer_protection_use_latency"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of config
+ if self.config:
+ _dict['config'] = self.config.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of icmpv6_rate_limit
+ if self.icmpv6_rate_limit:
+ _dict['icmpv6_rate_limit'] = self.icmpv6_rate_limit.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of jumbo_frame
+ if self.jumbo_frame:
+ _dict['jumbo_frame'] = self.jumbo_frame.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of nat
+ if self.nat:
+ _dict['nat'] = self.nat.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of nat64
+ if self.nat64:
+ _dict['nat64'] = self.nat64.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "accelerated_aging_enable": obj.get("accelerated_aging_enable") if obj.get("accelerated_aging_enable") is not None else True,
+ "accelerated_aging_scaling_factor": obj.get("accelerated_aging_scaling_factor") if obj.get("accelerated_aging_scaling_factor") is not None else 2,
+ "accelerated_aging_threshold": obj.get("accelerated_aging_threshold") if obj.get("accelerated_aging_threshold") is not None else 80,
+ "config": SessionSettingsSessionSettingsConfig.from_dict(obj["config"]) if obj.get("config") is not None else None,
+ "dhcp_bcast_session_on": obj.get("dhcp_bcast_session_on") if obj.get("dhcp_bcast_session_on") is not None else False,
+ "erspan": obj.get("erspan") if obj.get("erspan") is not None else False,
+ "icmp_unreachable_rate": obj.get("icmp_unreachable_rate") if obj.get("icmp_unreachable_rate") is not None else 200,
+ "icmpv6_rate_limit": SessionSettingsSessionSettingsIcmpv6RateLimit.from_dict(obj["icmpv6_rate_limit"]) if obj.get("icmpv6_rate_limit") is not None else None,
+ "ipv6_firewalling": obj.get("ipv6_firewalling") if obj.get("ipv6_firewalling") is not None else True,
+ "jumbo_frame": SessionSettingsSessionSettingsJumboFrame.from_dict(obj["jumbo_frame"]) if obj.get("jumbo_frame") is not None else None,
+ "max_pending_mcast_pkts_per_session": obj.get("max_pending_mcast_pkts_per_session") if obj.get("max_pending_mcast_pkts_per_session") is not None else 1000,
+ "multicast_route_setup_buffering": obj.get("multicast_route_setup_buffering") if obj.get("multicast_route_setup_buffering") is not None else False,
+ "nat": SessionSettingsSessionSettingsNat.from_dict(obj["nat"]) if obj.get("nat") is not None else None,
+ "nat64": SessionSettingsSessionSettingsNat64.from_dict(obj["nat64"]) if obj.get("nat64") is not None else None,
+ "packet_buffer_protection_activate": obj.get("packet_buffer_protection_activate") if obj.get("packet_buffer_protection_activate") is not None else 80,
+ "packet_buffer_protection_alert": obj.get("packet_buffer_protection_alert") if obj.get("packet_buffer_protection_alert") is not None else 50,
+ "packet_buffer_protection_block_countdown": obj.get("packet_buffer_protection_block_countdown") if obj.get("packet_buffer_protection_block_countdown") is not None else 80,
+ "packet_buffer_protection_block_duration_time": obj.get("packet_buffer_protection_block_duration_time") if obj.get("packet_buffer_protection_block_duration_time") is not None else 3600,
+ "packet_buffer_protection_block_hold_time": obj.get("packet_buffer_protection_block_hold_time") if obj.get("packet_buffer_protection_block_hold_time") is not None else 60,
+ "packet_buffer_protection_enable": obj.get("packet_buffer_protection_enable") if obj.get("packet_buffer_protection_enable") is not None else True,
+ "packet_buffer_protection_latency_activate": obj.get("packet_buffer_protection_latency_activate") if obj.get("packet_buffer_protection_latency_activate") is not None else 200,
+ "packet_buffer_protection_latency_alert": obj.get("packet_buffer_protection_latency_alert") if obj.get("packet_buffer_protection_latency_alert") is not None else 50,
+ "packet_buffer_protection_latency_block_countdown": obj.get("packet_buffer_protection_latency_block_countdown") if obj.get("packet_buffer_protection_latency_block_countdown") is not None else 500,
+ "packet_buffer_protection_latency_max_tolerate": obj.get("packet_buffer_protection_latency_max_tolerate") if obj.get("packet_buffer_protection_latency_max_tolerate") is not None else 500,
+ "packet_buffer_protection_monitor_only": obj.get("packet_buffer_protection_monitor_only") if obj.get("packet_buffer_protection_monitor_only") is not None else False,
+ "packet_buffer_protection_use_latency": obj.get("packet_buffer_protection_use_latency") if obj.get("packet_buffer_protection_use_latency") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_settings_session_settings_config.py b/scm/device_settings/models/session_settings_session_settings_config.py
new file mode 100644
index 00000000..40252034
--- /dev/null
+++ b/scm/device_settings/models/session_settings_session_settings_config.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionSettingsSessionSettingsConfig(BaseModel):
+ """
+ SessionSettingsSessionSettingsConfig
+ """ # noqa: E501
+ rematch: Optional[StrictBool] = Field(default=False, description="Rematch all sessions on config policy change")
+ __properties: ClassVar[List[str]] = ["rematch"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsConfig from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsConfig from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "rematch": obj.get("rematch") if obj.get("rematch") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_settings_session_settings_icmpv6_rate_limit.py b/scm/device_settings/models/session_settings_session_settings_icmpv6_rate_limit.py
new file mode 100644
index 00000000..bcc9bea2
--- /dev/null
+++ b/scm/device_settings/models/session_settings_session_settings_icmpv6_rate_limit.py
@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionSettingsSessionSettingsIcmpv6RateLimit(BaseModel):
+ """
+ ICMPv6 rate limiting
+ """ # noqa: E501
+ bucket_size: Optional[Annotated[int, Field(le=65535, strict=True, ge=10)]] = Field(default=100, description="ICMPv6 token bucket size")
+ packet_rate: Optional[Annotated[int, Field(le=65535, strict=True, ge=1)]] = Field(default=100, description="ICMPv6 error packet pate (per second)")
+ __properties: ClassVar[List[str]] = ["bucket_size", "packet_rate"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsIcmpv6RateLimit from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsIcmpv6RateLimit from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "bucket_size": obj.get("bucket_size") if obj.get("bucket_size") is not None else 100,
+ "packet_rate": obj.get("packet_rate") if obj.get("packet_rate") is not None else 100
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_settings_session_settings_jumbo_frame.py b/scm/device_settings/models/session_settings_session_settings_jumbo_frame.py
new file mode 100644
index 00000000..8fb012d1
--- /dev/null
+++ b/scm/device_settings/models/session_settings_session_settings_jumbo_frame.py
@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionSettingsSessionSettingsJumboFrame(BaseModel):
+ """
+ Enable jumbo frame support
+ """ # noqa: E501
+ mtu: Optional[Annotated[int, Field(le=9216, strict=True, ge=512)]] = Field(default=9192, description="Global MTU")
+ __properties: ClassVar[List[str]] = ["mtu"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsJumboFrame from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsJumboFrame from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "mtu": obj.get("mtu") if obj.get("mtu") is not None else 9192
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_settings_session_settings_nat.py b/scm/device_settings/models/session_settings_session_settings_nat.py
new file mode 100644
index 00000000..a57aedcc
--- /dev/null
+++ b/scm/device_settings/models/session_settings_session_settings_nat.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionSettingsSessionSettingsNat(BaseModel):
+ """
+ SessionSettingsSessionSettingsNat
+ """ # noqa: E501
+ dipp_oversub: Optional[StrictStr] = Field(default='1x', description="NAT oversubscription rate")
+ __properties: ClassVar[List[str]] = ["dipp_oversub"]
+
+ @field_validator('dipp_oversub')
+ def dipp_oversub_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['1x', '2x', '4x', '8x']):
+ raise ValueError("must be one of enum values ('1x', '2x', '4x', '8x')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsNat from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsNat from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "dipp_oversub": obj.get("dipp_oversub") if obj.get("dipp_oversub") is not None else '1x'
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_settings_session_settings_nat64.py b/scm/device_settings/models/session_settings_session_settings_nat64.py
new file mode 100644
index 00000000..31cf9ae0
--- /dev/null
+++ b/scm/device_settings/models/session_settings_session_settings_nat64.py
@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionSettingsSessionSettingsNat64(BaseModel):
+ """
+ SessionSettingsSessionSettingsNat64
+ """ # noqa: E501
+ ipv6_min_network_mtu: Optional[Annotated[int, Field(le=9216, strict=True, ge=1280)]] = Field(default=1280, description="NAT64 IPv6 minimum network MTU")
+ __properties: ClassVar[List[str]] = ["ipv6_min_network_mtu"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsNat64 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionSettingsSessionSettingsNat64 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ipv6_min_network_mtu": obj.get("ipv6_min_network_mtu") if obj.get("ipv6_min_network_mtu") is not None else 1280
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_timeouts.py b/scm/device_settings/models/session_timeouts.py
new file mode 100644
index 00000000..7b3c1145
--- /dev/null
+++ b/scm/device_settings/models/session_timeouts.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.session_timeouts_session_timeouts import SessionTimeoutsSessionTimeouts
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionTimeouts(BaseModel):
+ """
+ SessionTimeouts
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ session_timeouts: Optional[SessionTimeoutsSessionTimeouts] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "session_timeouts", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionTimeouts from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of session_timeouts
+ if self.session_timeouts:
+ _dict['session_timeouts'] = self.session_timeouts.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionTimeouts from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "session_timeouts": SessionTimeoutsSessionTimeouts.from_dict(obj["session_timeouts"]) if obj.get("session_timeouts") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/session_timeouts_session_timeouts.py b/scm/device_settings/models/session_timeouts_session_timeouts.py
new file mode 100644
index 00000000..6c6e595c
--- /dev/null
+++ b/scm/device_settings/models/session_timeouts_session_timeouts.py
@@ -0,0 +1,115 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SessionTimeoutsSessionTimeouts(BaseModel):
+ """
+ SessionTimeoutsSessionTimeouts
+ """ # noqa: E501
+ timeout_captive_portal: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=30, description="Captive Portal (seconds)")
+ timeout_default: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=30, description="Default timeout (seconds)")
+ timeout_discard_default: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=60, description="Discard default (seconds)")
+ timeout_discard_tcp: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=90, description="Discard TCP (seconds)")
+ timeout_discard_udp: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=60, description="Discard UDP (seconds)")
+ timeout_icmp: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=6, description="ICMP (seconds)")
+ timeout_scan: Optional[Annotated[int, Field(le=30, strict=True, ge=5)]] = Field(default=10, description="Scan (seconds)")
+ timeout_tcp: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=3600, description="TCP (seconds)")
+ timeout_tcp_half_closed: Optional[Annotated[int, Field(le=604800, strict=True, ge=1)]] = Field(default=120, description="TCP Half Closed (seconds)")
+ timeout_tcp_time_wait: Optional[Annotated[int, Field(le=600, strict=True, ge=1)]] = Field(default=15, description="TCP Time Wait (seconds)")
+ timeout_tcp_unverified_rst: Optional[Annotated[int, Field(le=600, strict=True, ge=1)]] = Field(default=30, description="Unverified RST (seconds)")
+ timeout_tcphandshake: Optional[Annotated[int, Field(le=60, strict=True, ge=1)]] = Field(default=10, description="TCP handshake (seconds)")
+ timeout_tcpinit: Optional[Annotated[int, Field(le=60, strict=True, ge=1)]] = Field(default=5, description="TCP init (seconds)")
+ timeout_udp: Optional[Annotated[int, Field(le=15999999, strict=True, ge=1)]] = Field(default=30, description="UDP (seconds)")
+ __properties: ClassVar[List[str]] = ["timeout_captive_portal", "timeout_default", "timeout_discard_default", "timeout_discard_tcp", "timeout_discard_udp", "timeout_icmp", "timeout_scan", "timeout_tcp", "timeout_tcp_half_closed", "timeout_tcp_time_wait", "timeout_tcp_unverified_rst", "timeout_tcphandshake", "timeout_tcpinit", "timeout_udp"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SessionTimeoutsSessionTimeouts from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SessionTimeoutsSessionTimeouts from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "timeout_captive_portal": obj.get("timeout_captive_portal") if obj.get("timeout_captive_portal") is not None else 30,
+ "timeout_default": obj.get("timeout_default") if obj.get("timeout_default") is not None else 30,
+ "timeout_discard_default": obj.get("timeout_discard_default") if obj.get("timeout_discard_default") is not None else 60,
+ "timeout_discard_tcp": obj.get("timeout_discard_tcp") if obj.get("timeout_discard_tcp") is not None else 90,
+ "timeout_discard_udp": obj.get("timeout_discard_udp") if obj.get("timeout_discard_udp") is not None else 60,
+ "timeout_icmp": obj.get("timeout_icmp") if obj.get("timeout_icmp") is not None else 6,
+ "timeout_scan": obj.get("timeout_scan") if obj.get("timeout_scan") is not None else 10,
+ "timeout_tcp": obj.get("timeout_tcp") if obj.get("timeout_tcp") is not None else 3600,
+ "timeout_tcp_half_closed": obj.get("timeout_tcp_half_closed") if obj.get("timeout_tcp_half_closed") is not None else 120,
+ "timeout_tcp_time_wait": obj.get("timeout_tcp_time_wait") if obj.get("timeout_tcp_time_wait") is not None else 15,
+ "timeout_tcp_unverified_rst": obj.get("timeout_tcp_unverified_rst") if obj.get("timeout_tcp_unverified_rst") is not None else 30,
+ "timeout_tcphandshake": obj.get("timeout_tcphandshake") if obj.get("timeout_tcphandshake") is not None else 10,
+ "timeout_tcpinit": obj.get("timeout_tcpinit") if obj.get("timeout_tcpinit") is not None else 5,
+ "timeout_udp": obj.get("timeout_udp") if obj.get("timeout_udp") is not None else 30
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/tcp_settings.py b/scm/device_settings/models/tcp_settings.py
new file mode 100644
index 00000000..b0c4b870
--- /dev/null
+++ b/scm/device_settings/models/tcp_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.tcp_settings_tcp import TcpSettingsTcp
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TcpSettings(BaseModel):
+ """
+ TcpSettings
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ tcp: Optional[TcpSettingsTcp] = None
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "snippet", "tcp"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TcpSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of tcp
+ if self.tcp:
+ _dict['tcp'] = self.tcp.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TcpSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "snippet": obj.get("snippet"),
+ "tcp": TcpSettingsTcp.from_dict(obj["tcp"]) if obj.get("tcp") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/tcp_settings_tcp.py b/scm/device_settings/models/tcp_settings_tcp.py
new file mode 100644
index 00000000..9fe4b0b8
--- /dev/null
+++ b/scm/device_settings/models/tcp_settings_tcp.py
@@ -0,0 +1,134 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TcpSettingsTcp(BaseModel):
+ """
+ TcpSettingsTcp
+ """ # noqa: E501
+ allow_challenge_ack: Optional[StrictBool] = Field(default=None, description="Allow arbitrary ACK in response to SYN?")
+ asymmetric_path: Optional[StrictStr] = Field(default=None, description="Asymmetric path action")
+ bypass_exceed_oo_queue: Optional[StrictBool] = Field(default=None, description="Forward segments exceeding TCP out-of-order queue?")
+ check_timestamp_option: Optional[StrictBool] = Field(default=None, description="Drop segments with null timestamp option?")
+ drop_zero_flag: Optional[StrictBool] = Field(default=None, description="Drop segments without flag?")
+ siptcp_cleartext_proxy: Optional[StrictStr] = Field(default=None, description="SIP TCP cleartext action (`'0'` = Always Off, `'1'` = Always Enabled, `'2'` = Automatically enable proxy when needed)")
+ strip_mptcp_option: Optional[StrictBool] = Field(default=None, description="Strip MPTCP option?")
+ tcp_retransmit_scan: Optional[StrictBool] = Field(default=None, description="TCP retransmit scan?")
+ urgent_data: Optional[StrictStr] = Field(default=None, description="Urgent data flag action")
+ __properties: ClassVar[List[str]] = ["allow_challenge_ack", "asymmetric_path", "bypass_exceed_oo_queue", "check_timestamp_option", "drop_zero_flag", "siptcp_cleartext_proxy", "strip_mptcp_option", "tcp_retransmit_scan", "urgent_data"]
+
+ @field_validator('asymmetric_path')
+ def asymmetric_path_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['drop', 'bypass']):
+ raise ValueError("must be one of enum values ('drop', 'bypass')")
+ return value
+
+ @field_validator('siptcp_cleartext_proxy')
+ def siptcp_cleartext_proxy_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['0', '2', '3']):
+ raise ValueError("must be one of enum values ('0', '2', '3')")
+ return value
+
+ @field_validator('urgent_data')
+ def urgent_data_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['clear', 'oobinline']):
+ raise ValueError("must be one of enum values ('clear', 'oobinline')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TcpSettingsTcp from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TcpSettingsTcp from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "allow_challenge_ack": obj.get("allow_challenge_ack"),
+ "asymmetric_path": obj.get("asymmetric_path"),
+ "bypass_exceed_oo_queue": obj.get("bypass_exceed_oo_queue"),
+ "check_timestamp_option": obj.get("check_timestamp_option"),
+ "drop_zero_flag": obj.get("drop_zero_flag"),
+ "siptcp_cleartext_proxy": obj.get("siptcp_cleartext_proxy"),
+ "strip_mptcp_option": obj.get("strip_mptcp_option"),
+ "tcp_retransmit_scan": obj.get("tcp_retransmit_scan"),
+ "urgent_data": obj.get("urgent_data")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule.py b/scm/device_settings/models/update_schedule.py
new file mode 100644
index 00000000..28d52f8a
--- /dev/null
+++ b/scm/device_settings/models/update_schedule.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.update_schedule_update_schedule import UpdateScheduleUpdateSchedule
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateSchedule(BaseModel):
+ """
+ UpdateSchedule
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ update_schedule: Optional[UpdateScheduleUpdateSchedule] = None
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "snippet", "update_schedule"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateSchedule from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of update_schedule
+ if self.update_schedule:
+ _dict['update_schedule'] = self.update_schedule.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateSchedule from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "snippet": obj.get("snippet"),
+ "update_schedule": UpdateScheduleUpdateSchedule.from_dict(obj["update_schedule"]) if obj.get("update_schedule") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule.py b/scm/device_settings/models/update_schedule_update_schedule.py
new file mode 100644
index 00000000..f445ef4e
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule.py
@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus import UpdateScheduleUpdateScheduleAntiVirus
+from scm.device_settings.models.update_schedule_update_schedule_threats import UpdateScheduleUpdateScheduleThreats
+from scm.device_settings.models.update_schedule_update_schedule_wildfire import UpdateScheduleUpdateScheduleWildfire
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateSchedule(BaseModel):
+ """
+ UpdateScheduleUpdateSchedule
+ """ # noqa: E501
+ anti_virus: UpdateScheduleUpdateScheduleAntiVirus
+ threats: UpdateScheduleUpdateScheduleThreats
+ wildfire: UpdateScheduleUpdateScheduleWildfire
+ __properties: ClassVar[List[str]] = ["anti_virus", "threats", "wildfire"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateSchedule from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of anti_virus
+ if self.anti_virus:
+ _dict['anti_virus'] = self.anti_virus.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of threats
+ if self.threats:
+ _dict['threats'] = self.threats.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of wildfire
+ if self.wildfire:
+ _dict['wildfire'] = self.wildfire.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateSchedule from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "anti_virus": UpdateScheduleUpdateScheduleAntiVirus.from_dict(obj["anti_virus"]) if obj.get("anti_virus") is not None else None,
+ "threats": UpdateScheduleUpdateScheduleThreats.from_dict(obj["threats"]) if obj.get("threats") is not None else None,
+ "wildfire": UpdateScheduleUpdateScheduleWildfire.from_dict(obj["wildfire"]) if obj.get("wildfire") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_anti_virus.py b/scm/device_settings/models/update_schedule_update_schedule_anti_virus.py
new file mode 100644
index 00000000..709b35fe
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_anti_virus.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring import UpdateScheduleUpdateScheduleAntiVirusRecurring
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleAntiVirus(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleAntiVirus
+ """ # noqa: E501
+ recurring: UpdateScheduleUpdateScheduleAntiVirusRecurring
+ __properties: ClassVar[List[str]] = ["recurring"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirus from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of recurring
+ if self.recurring:
+ _dict['recurring'] = self.recurring.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirus from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "recurring": UpdateScheduleUpdateScheduleAntiVirusRecurring.from_dict(obj["recurring"]) if obj.get("recurring") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring.py b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring.py
new file mode 100644
index 00000000..49851a7a
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring.py
@@ -0,0 +1,111 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_daily import UpdateScheduleUpdateScheduleAntiVirusRecurringDaily
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_hourly import UpdateScheduleUpdateScheduleAntiVirusRecurringHourly
+from scm.device_settings.models.update_schedule_update_schedule_anti_virus_recurring_weekly import UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleAntiVirusRecurring(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleAntiVirusRecurring
+ """ # noqa: E501
+ daily: Optional[UpdateScheduleUpdateScheduleAntiVirusRecurringDaily] = None
+ hourly: Optional[UpdateScheduleUpdateScheduleAntiVirusRecurringHourly] = None
+ var_none: Optional[Dict[str, Any]] = Field(default=None, alias="none")
+ sync_to_peer: StrictBool
+ threshold: Optional[Annotated[int, Field(le=336, strict=True, ge=1)]] = None
+ weekly: Optional[UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly] = None
+ __properties: ClassVar[List[str]] = ["daily", "hourly", "none", "sync_to_peer", "threshold", "weekly"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurring from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of daily
+ if self.daily:
+ _dict['daily'] = self.daily.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of hourly
+ if self.hourly:
+ _dict['hourly'] = self.hourly.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of weekly
+ if self.weekly:
+ _dict['weekly'] = self.weekly.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurring from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "daily": UpdateScheduleUpdateScheduleAntiVirusRecurringDaily.from_dict(obj["daily"]) if obj.get("daily") is not None else None,
+ "hourly": UpdateScheduleUpdateScheduleAntiVirusRecurringHourly.from_dict(obj["hourly"]) if obj.get("hourly") is not None else None,
+ "none": obj.get("none"),
+ "sync_to_peer": obj.get("sync_to_peer") if obj.get("sync_to_peer") is not None else False,
+ "threshold": obj.get("threshold"),
+ "weekly": UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly.from_dict(obj["weekly"]) if obj.get("weekly") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_daily.py b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_daily.py
new file mode 100644
index 00000000..755dfa8e
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_daily.py
@@ -0,0 +1,108 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleAntiVirusRecurringDaily(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleAntiVirusRecurringDaily
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Annotated[str, Field(strict=True)]
+ __properties: ClassVar[List[str]] = ["action", "at"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ @field_validator('at')
+ def at_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if not re.match(r"^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$", value):
+ raise ValueError(r"must validate the regular expression /^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringDaily from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringDaily from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_hourly.py b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_hourly.py
new file mode 100644
index 00000000..35aa8dd7
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_hourly.py
@@ -0,0 +1,101 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleAntiVirusRecurringHourly(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleAntiVirusRecurringHourly
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Annotated[int, Field(le=59, strict=True, ge=0)]
+ __properties: ClassVar[List[str]] = ["action", "at"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringHourly from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringHourly from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at") if obj.get("at") is not None else 0
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_weekly.py b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_weekly.py
new file mode 100644
index 00000000..c0abd29c
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_anti_virus_recurring_weekly.py
@@ -0,0 +1,123 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Optional[Annotated[str, Field(strict=True)]] = None
+ day_of_week: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["action", "at", "day_of_week"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ @field_validator('at')
+ def at_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$", value):
+ raise ValueError(r"must validate the regular expression /^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/")
+ return value
+
+ @field_validator('day_of_week')
+ def day_of_week_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday']):
+ raise ValueError("must be one of enum values ('sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleAntiVirusRecurringWeekly from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at"),
+ "day_of_week": obj.get("day_of_week")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_threats.py b/scm/device_settings/models/update_schedule_update_schedule_threats.py
new file mode 100644
index 00000000..5c6ac57d
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_threats.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring import UpdateScheduleUpdateScheduleThreatsRecurring
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleThreats(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleThreats
+ """ # noqa: E501
+ recurring: UpdateScheduleUpdateScheduleThreatsRecurring
+ __properties: ClassVar[List[str]] = ["recurring"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreats from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of recurring
+ if self.recurring:
+ _dict['recurring'] = self.recurring.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreats from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "recurring": UpdateScheduleUpdateScheduleThreatsRecurring.from_dict(obj["recurring"]) if obj.get("recurring") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_threats_recurring.py b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring.py
new file mode 100644
index 00000000..da352531
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring.py
@@ -0,0 +1,119 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_daily import UpdateScheduleUpdateScheduleThreatsRecurringDaily
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_every30_mins import UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_hourly import UpdateScheduleUpdateScheduleThreatsRecurringHourly
+from scm.device_settings.models.update_schedule_update_schedule_threats_recurring_weekly import UpdateScheduleUpdateScheduleThreatsRecurringWeekly
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleThreatsRecurring(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleThreatsRecurring
+ """ # noqa: E501
+ daily: Optional[UpdateScheduleUpdateScheduleThreatsRecurringDaily] = None
+ every_30_mins: Optional[UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins] = None
+ hourly: Optional[UpdateScheduleUpdateScheduleThreatsRecurringHourly] = None
+ new_app_threshold: Optional[Annotated[int, Field(le=336, strict=True, ge=1)]] = None
+ var_none: Optional[Dict[str, Any]] = Field(default=None, alias="none")
+ sync_to_peer: StrictBool
+ threshold: Optional[Annotated[int, Field(le=336, strict=True, ge=1)]] = None
+ weekly: Optional[UpdateScheduleUpdateScheduleThreatsRecurringWeekly] = None
+ __properties: ClassVar[List[str]] = ["daily", "every_30_mins", "hourly", "new_app_threshold", "none", "sync_to_peer", "threshold", "weekly"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurring from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of daily
+ if self.daily:
+ _dict['daily'] = self.daily.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of every_30_mins
+ if self.every_30_mins:
+ _dict['every_30_mins'] = self.every_30_mins.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of hourly
+ if self.hourly:
+ _dict['hourly'] = self.hourly.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of weekly
+ if self.weekly:
+ _dict['weekly'] = self.weekly.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurring from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "daily": UpdateScheduleUpdateScheduleThreatsRecurringDaily.from_dict(obj["daily"]) if obj.get("daily") is not None else None,
+ "every_30_mins": UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins.from_dict(obj["every_30_mins"]) if obj.get("every_30_mins") is not None else None,
+ "hourly": UpdateScheduleUpdateScheduleThreatsRecurringHourly.from_dict(obj["hourly"]) if obj.get("hourly") is not None else None,
+ "new_app_threshold": obj.get("new_app_threshold"),
+ "none": obj.get("none"),
+ "sync_to_peer": obj.get("sync_to_peer") if obj.get("sync_to_peer") is not None else False,
+ "threshold": obj.get("threshold"),
+ "weekly": UpdateScheduleUpdateScheduleThreatsRecurringWeekly.from_dict(obj["weekly"]) if obj.get("weekly") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_daily.py b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_daily.py
new file mode 100644
index 00000000..c70afddf
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_daily.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleThreatsRecurringDaily(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleThreatsRecurringDaily
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Annotated[str, Field(strict=True)]
+ disable_new_content: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "at", "disable_new_content"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ @field_validator('at')
+ def at_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if not re.match(r"^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$", value):
+ raise ValueError(r"must validate the regular expression /^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringDaily from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringDaily from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at"),
+ "disable_new_content": obj.get("disable_new_content") if obj.get("disable_new_content") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_every30_mins.py b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_every30_mins.py
new file mode 100644
index 00000000..57d8a063
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_every30_mins.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Optional[Annotated[int, Field(le=29, strict=True, ge=0)]] = 0
+ disable_new_content: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "at", "disable_new_content"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringEvery30Mins from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at") if obj.get("at") is not None else 0,
+ "disable_new_content": obj.get("disable_new_content") if obj.get("disable_new_content") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_hourly.py b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_hourly.py
new file mode 100644
index 00000000..1d442c3f
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_hourly.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleThreatsRecurringHourly(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleThreatsRecurringHourly
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Union[Annotated[float, Field(le=59, strict=True, ge=0)], Annotated[int, Field(le=59, strict=True, ge=0)]]
+ disable_new_content: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "at", "disable_new_content"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringHourly from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringHourly from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at") if obj.get("at") is not None else 0,
+ "disable_new_content": obj.get("disable_new_content") if obj.get("disable_new_content") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_weekly.py b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_weekly.py
new file mode 100644
index 00000000..10c9610a
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_threats_recurring_weekly.py
@@ -0,0 +1,119 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleThreatsRecurringWeekly(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleThreatsRecurringWeekly
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Annotated[str, Field(strict=True)]
+ day_of_week: StrictStr
+ disable_new_content: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "at", "day_of_week", "disable_new_content"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ @field_validator('at')
+ def at_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if not re.match(r"^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$", value):
+ raise ValueError(r"must validate the regular expression /^(0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$/")
+ return value
+
+ @field_validator('day_of_week')
+ def day_of_week_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday']):
+ raise ValueError("must be one of enum values ('sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringWeekly from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleThreatsRecurringWeekly from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at"),
+ "day_of_week": obj.get("day_of_week"),
+ "disable_new_content": obj.get("disable_new_content") if obj.get("disable_new_content") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_wildfire.py b/scm/device_settings/models/update_schedule_update_schedule_wildfire.py
new file mode 100644
index 00000000..53abe403
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_wildfire.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring import UpdateScheduleUpdateScheduleWildfireRecurring
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleWildfire(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleWildfire
+ """ # noqa: E501
+ recurring: UpdateScheduleUpdateScheduleWildfireRecurring
+ __properties: ClassVar[List[str]] = ["recurring"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfire from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of recurring
+ if self.recurring:
+ _dict['recurring'] = self.recurring.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfire from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "recurring": UpdateScheduleUpdateScheduleWildfireRecurring.from_dict(obj["recurring"]) if obj.get("recurring") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring.py b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring.py
new file mode 100644
index 00000000..53310ca6
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring.py
@@ -0,0 +1,114 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every15_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every30_mins import UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_hour import UpdateScheduleUpdateScheduleWildfireRecurringEveryHour
+from scm.device_settings.models.update_schedule_update_schedule_wildfire_recurring_every_min import UpdateScheduleUpdateScheduleWildfireRecurringEveryMin
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleWildfireRecurring(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleWildfireRecurring
+ """ # noqa: E501
+ every_15_mins: Optional[UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins] = None
+ every_30_mins: Optional[UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins] = None
+ every_hour: Optional[UpdateScheduleUpdateScheduleWildfireRecurringEveryHour] = None
+ every_min: Optional[UpdateScheduleUpdateScheduleWildfireRecurringEveryMin] = None
+ var_none: Optional[Dict[str, Any]] = Field(default=None, alias="none")
+ real_time: Optional[Dict[str, Any]] = None
+ __properties: ClassVar[List[str]] = ["every_15_mins", "every_30_mins", "every_hour", "every_min", "none", "real_time"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurring from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of every_15_mins
+ if self.every_15_mins:
+ _dict['every_15_mins'] = self.every_15_mins.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of every_30_mins
+ if self.every_30_mins:
+ _dict['every_30_mins'] = self.every_30_mins.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of every_hour
+ if self.every_hour:
+ _dict['every_hour'] = self.every_hour.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of every_min
+ if self.every_min:
+ _dict['every_min'] = self.every_min.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurring from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "every_15_mins": UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins.from_dict(obj["every_15_mins"]) if obj.get("every_15_mins") is not None else None,
+ "every_30_mins": UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins.from_dict(obj["every_30_mins"]) if obj.get("every_30_mins") is not None else None,
+ "every_hour": UpdateScheduleUpdateScheduleWildfireRecurringEveryHour.from_dict(obj["every_hour"]) if obj.get("every_hour") is not None else None,
+ "every_min": UpdateScheduleUpdateScheduleWildfireRecurringEveryMin.from_dict(obj["every_min"]) if obj.get("every_min") is not None else None,
+ "none": obj.get("none"),
+ "real_time": obj.get("real_time")
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every15_mins.py b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every15_mins.py
new file mode 100644
index 00000000..ce8a0317
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every15_mins.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Optional[Annotated[int, Field(le=14, strict=True, ge=0)]] = 0
+ sync_to_peer: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "at", "sync_to_peer"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery15Mins from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at") if obj.get("at") is not None else 0,
+ "sync_to_peer": obj.get("sync_to_peer") if obj.get("sync_to_peer") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every30_mins.py b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every30_mins.py
new file mode 100644
index 00000000..40e7f291
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every30_mins.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Optional[Annotated[int, Field(le=29, strict=True, ge=0)]] = 0
+ sync_to_peer: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "at", "sync_to_peer"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEvery30Mins from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at") if obj.get("at") is not None else 0,
+ "sync_to_peer": obj.get("sync_to_peer") if obj.get("sync_to_peer") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every_hour.py b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every_hour.py
new file mode 100644
index 00000000..b48465b2
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every_hour.py
@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleWildfireRecurringEveryHour(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleWildfireRecurringEveryHour
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ at: Optional[Annotated[int, Field(le=59, strict=True, ge=0)]] = 0
+ sync_to_peer: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "at", "sync_to_peer"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryHour from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryHour from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "at": obj.get("at") if obj.get("at") is not None else 0,
+ "sync_to_peer": obj.get("sync_to_peer") if obj.get("sync_to_peer") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every_min.py b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every_min.py
new file mode 100644
index 00000000..da962907
--- /dev/null
+++ b/scm/device_settings/models/update_schedule_update_schedule_wildfire_recurring_every_min.py
@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class UpdateScheduleUpdateScheduleWildfireRecurringEveryMin(BaseModel):
+ """
+ UpdateScheduleUpdateScheduleWildfireRecurringEveryMin
+ """ # noqa: E501
+ action: Optional[StrictStr] = None
+ sync_to_peer: Optional[StrictBool] = False
+ __properties: ClassVar[List[str]] = ["action", "sync_to_peer"]
+
+ @field_validator('action')
+ def action_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['download-only', 'download-and-install']):
+ raise ValueError("must be one of enum values ('download-only', 'download-and-install')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryMin from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of UpdateScheduleUpdateScheduleWildfireRecurringEveryMin from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "action": obj.get("action"),
+ "sync_to_peer": obj.get("sync_to_peer") if obj.get("sync_to_peer") is not None else False
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/vpn_settings.py b/scm/device_settings/models/vpn_settings.py
new file mode 100644
index 00000000..667a2628
--- /dev/null
+++ b/scm/device_settings/models/vpn_settings.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.device_settings.models.vpn_settings_vpn import VpnSettingsVpn
+from typing import Optional, Set
+from typing_extensions import Self
+
+class VpnSettings(BaseModel):
+ """
+ VpnSettings
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="UUID of the resource")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ vpn: Optional[VpnSettingsVpn] = None
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "snippet", "vpn"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of VpnSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of vpn
+ if self.vpn:
+ _dict['vpn'] = self.vpn.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of VpnSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "snippet": obj.get("snippet"),
+ "vpn": VpnSettingsVpn.from_dict(obj["vpn"]) if obj.get("vpn") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/vpn_settings_vpn.py b/scm/device_settings/models/vpn_settings_vpn.py
new file mode 100644
index 00000000..ccd272fe
--- /dev/null
+++ b/scm/device_settings/models/vpn_settings_vpn.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.device_settings.models.vpn_settings_vpn_ikev2 import VpnSettingsVpnIkev2
+from typing import Optional, Set
+from typing_extensions import Self
+
+class VpnSettingsVpn(BaseModel):
+ """
+ VpnSettingsVpn
+ """ # noqa: E501
+ ikev2: Optional[VpnSettingsVpnIkev2] = None
+ __properties: ClassVar[List[str]] = ["ikev2"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of VpnSettingsVpn from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of ikev2
+ if self.ikev2:
+ _dict['ikev2'] = self.ikev2.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of VpnSettingsVpn from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ikev2": VpnSettingsVpnIkev2.from_dict(obj["ikev2"]) if obj.get("ikev2") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/models/vpn_settings_vpn_ikev2.py b/scm/device_settings/models/vpn_settings_vpn_ikev2.py
new file mode 100644
index 00000000..7f3b1a50
--- /dev/null
+++ b/scm/device_settings/models/vpn_settings_vpn_ikev2.py
@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class VpnSettingsVpnIkev2(BaseModel):
+ """
+ VpnSettingsVpnIkev2
+ """ # noqa: E501
+ certificate_cache_size: Optional[Annotated[int, Field(le=4000, strict=True, ge=0)]] = Field(default=500, description="Maximum cached certificates")
+ cookie_threshold: Optional[Annotated[int, Field(le=65535, strict=True, ge=0)]] = Field(default=500, description="Cookie activation threshold")
+ max_half_opened_sa: Optional[Annotated[int, Field(le=65535, strict=True, ge=1)]] = Field(default=65535, description="Maximum half-opened SA")
+ __properties: ClassVar[List[str]] = ["certificate_cache_size", "cookie_threshold", "max_half_opened_sa"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of VpnSettingsVpnIkev2 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of VpnSettingsVpnIkev2 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "certificate_cache_size": obj.get("certificate_cache_size") if obj.get("certificate_cache_size") is not None else 500,
+ "cookie_threshold": obj.get("cookie_threshold") if obj.get("cookie_threshold") is not None else 500,
+ "max_half_opened_sa": obj.get("max_half_opened_sa") if obj.get("max_half_opened_sa") is not None else 65535
+ })
+ return _obj
+
+
diff --git a/scm/device_settings/rest.py b/scm/device_settings/rest.py
new file mode 100644
index 00000000..26758c28
--- /dev/null
+++ b/scm/device_settings/rest.py
@@ -0,0 +1,258 @@
+# coding: utf-8
+
+"""
+ Device Settings
+
+ These APIs are used for defining and managing device configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import io
+import json
+import re
+import ssl
+
+import urllib3
+
+from scm.device_settings.exceptions import ApiException, ApiValueError
+
+SUPPORTED_SOCKS_PROXIES = {"socks5", "socks5h", "socks4", "socks4a"}
+RESTResponseType = urllib3.HTTPResponse
+
+
+def is_socks_proxy_url(url):
+ if url is None:
+ return False
+ split_section = url.split("://")
+ if len(split_section) < 2:
+ return False
+ else:
+ return split_section[0].lower() in SUPPORTED_SOCKS_PROXIES
+
+
+class RESTResponse(io.IOBase):
+
+ def __init__(self, resp) -> None:
+ self.response = resp
+ self.status = resp.status
+ self.reason = resp.reason
+ self.data = None
+
+ def read(self):
+ if self.data is None:
+ self.data = self.response.data
+ return self.data
+
+ def getheaders(self):
+ """Returns a dictionary of the response headers."""
+ return self.response.headers
+
+ def getheader(self, name, default=None):
+ """Returns a given response header."""
+ return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+ def __init__(self, configuration) -> None:
+ # urllib3.PoolManager will pass all kw parameters to connectionpool
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501
+ # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501
+
+ # cert_reqs
+ if configuration.verify_ssl:
+ cert_reqs = ssl.CERT_REQUIRED
+ else:
+ cert_reqs = ssl.CERT_NONE
+
+ pool_args = {
+ "cert_reqs": cert_reqs,
+ "ca_certs": configuration.ssl_ca_cert,
+ "cert_file": configuration.cert_file,
+ "key_file": configuration.key_file,
+ }
+ if configuration.assert_hostname is not None:
+ pool_args['assert_hostname'] = (
+ configuration.assert_hostname
+ )
+
+ if configuration.retries is not None:
+ pool_args['retries'] = configuration.retries
+
+ if configuration.tls_server_name:
+ pool_args['server_hostname'] = configuration.tls_server_name
+
+
+ if configuration.socket_options is not None:
+ pool_args['socket_options'] = configuration.socket_options
+
+ if configuration.connection_pool_maxsize is not None:
+ pool_args['maxsize'] = configuration.connection_pool_maxsize
+
+ # https pool manager
+ self.pool_manager: urllib3.PoolManager
+
+ if configuration.proxy:
+ if is_socks_proxy_url(configuration.proxy):
+ from urllib3.contrib.socks import SOCKSProxyManager
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["headers"] = configuration.proxy_headers
+ self.pool_manager = SOCKSProxyManager(**pool_args)
+ else:
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["proxy_headers"] = configuration.proxy_headers
+ self.pool_manager = urllib3.ProxyManager(**pool_args)
+ else:
+ self.pool_manager = urllib3.PoolManager(**pool_args)
+
+ def request(
+ self,
+ method,
+ url,
+ headers=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ):
+ """Perform requests.
+
+ :param method: http request method
+ :param url: http request url
+ :param headers: http request headers
+ :param body: request json body, for `application/json`
+ :param post_params: request post parameters,
+ `application/x-www-form-urlencoded`
+ and `multipart/form-data`
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ """
+ method = method.upper()
+ assert method in [
+ 'GET',
+ 'HEAD',
+ 'DELETE',
+ 'POST',
+ 'PUT',
+ 'PATCH',
+ 'OPTIONS'
+ ]
+
+ if post_params and body:
+ raise ApiValueError(
+ "body parameter cannot be used with post_params parameter."
+ )
+
+ post_params = post_params or {}
+ headers = headers or {}
+
+ timeout = None
+ if _request_timeout:
+ if isinstance(_request_timeout, (int, float)):
+ timeout = urllib3.Timeout(total=_request_timeout)
+ elif (
+ isinstance(_request_timeout, tuple)
+ and len(_request_timeout) == 2
+ ):
+ timeout = urllib3.Timeout(
+ connect=_request_timeout[0],
+ read=_request_timeout[1]
+ )
+
+ try:
+ # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+ if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+
+ # no content type provided or payload is json
+ content_type = headers.get('Content-Type')
+ if (
+ not content_type
+ or re.search('json', content_type, re.IGNORECASE)
+ ):
+ request_body = None
+ if body is not None:
+ request_body = json.dumps(body)
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'application/x-www-form-urlencoded':
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=False,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'multipart/form-data':
+ # must del headers['Content-Type'], or the correct
+ # Content-Type which generated by urllib3 will be
+ # overwritten.
+ del headers['Content-Type']
+ # Ensures that dict objects are serialized
+ post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a,b) for a, b in post_params]
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=True,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ # Pass a `string` parameter directly in the body to support
+ # other content types than JSON when `body` argument is
+ # provided in serialized form.
+ elif isinstance(body, str) or isinstance(body, bytes):
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif headers['Content-Type'].startswith('text/') and isinstance(body, bool):
+ request_body = "true" if body else "false"
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ preload_content=False,
+ timeout=timeout,
+ headers=headers)
+ else:
+ # Cannot generate the request from given parameters
+ msg = """Cannot prepare a request message for provided
+ arguments. Please check that your arguments match
+ declared content type."""
+ raise ApiException(status=0, reason=msg)
+ # For `GET`, `HEAD`
+ else:
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields={},
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ except urllib3.exceptions.SSLError as e:
+ msg = "\n".join([type(e).__name__, str(e)])
+ raise ApiException(status=0, reason=msg)
+
+ return RESTResponse(r)
diff --git a/scm/device_settings/tests/__init__.py b/scm/device_settings/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/scm/device_settings/tests/api_authentication_settings_test.py b/scm/device_settings/tests/api_authentication_settings_test.py
new file mode 100644
index 00000000..c5e1ab6c
--- /dev/null
+++ b/scm/device_settings/tests/api_authentication_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def authentication_settings_api(client):
+ return client.device_settings.AuthenticationSettingsApi(client.device_settings.api_client)
+
+
+def test_list_authentication_settings(authentication_settings_api):
+ """Test listing authentication settings (singleton per folder)."""
+ response = authentication_settings_api.list_authentication_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} authentication settings items")
+
+
+def test_get_authentication_settings_by_id(authentication_settings_api):
+ """Test getting authentication settings by ID."""
+ response = authentication_settings_api.list_authentication_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = authentication_settings_api.get_authentication_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got authentication settings by ID: {obj.id}")
+
+
+def test_update_authentication_settings(authentication_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = authentication_settings_api.list_authentication_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = authentication_settings_api.update_authentication_settings_by_id(
+ id=existing.id,
+ authentication_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated authentication settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_content_id_settings_test.py b/scm/device_settings/tests/api_content_id_settings_test.py
new file mode 100644
index 00000000..95faf389
--- /dev/null
+++ b/scm/device_settings/tests/api_content_id_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def content_id_settings_api(client):
+ return client.device_settings.ContentIDSettingsApi(client.device_settings.api_client)
+
+
+def test_list_content_id_settings(content_id_settings_api):
+ """Test listing content ID settings (singleton per folder)."""
+ response = content_id_settings_api.list_content_id_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} content ID settings items")
+
+
+def test_get_content_id_settings_by_id(content_id_settings_api):
+ """Test getting content ID settings by ID."""
+ response = content_id_settings_api.list_content_id_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items — device-specific setting, requires managed device")
+ obj = content_id_settings_api.get_content_id_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got content ID settings by ID: {obj.id}")
+
+
+def test_update_content_id_settings(content_id_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = content_id_settings_api.list_content_id_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items — device-specific setting, requires managed device")
+ existing = response[0]
+ updated = content_id_settings_api.update_content_id_settings_by_id(
+ id=existing.id,
+ content_id_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated content ID settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_device_redistribution_collector_settings_test.py b/scm/device_settings/tests/api_device_redistribution_collector_settings_test.py
new file mode 100644
index 00000000..1174563e
--- /dev/null
+++ b/scm/device_settings/tests/api_device_redistribution_collector_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def device_redistribution_collector_settings_api(client):
+ return client.device_settings.DeviceRedistributionCollectorSettingsApi(client.device_settings.api_client)
+
+
+def test_list_device_redistribution_collector_settings(device_redistribution_collector_settings_api):
+ """Test listing device redistribution collector settings (singleton per folder)."""
+ response = device_redistribution_collector_settings_api.list_device_redistribution_collector_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} device redistribution collector settings items")
+
+
+def test_get_device_redistribution_collector_settings_by_id(device_redistribution_collector_settings_api):
+ """Test getting device redistribution collector settings by ID."""
+ response = device_redistribution_collector_settings_api.list_device_redistribution_collector_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = device_redistribution_collector_settings_api.get_device_redistribution_collector_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got device redistribution collector settings by ID: {obj.id}")
+
+
+def test_update_device_redistribution_collector_settings(device_redistribution_collector_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = device_redistribution_collector_settings_api.list_device_redistribution_collector_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = device_redistribution_collector_settings_api.update_device_redistribution_collector_settings_by_id(
+ id=existing.id,
+ device_redistribution_collector=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated device redistribution collector settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_general_settings_test.py b/scm/device_settings/tests/api_general_settings_test.py
new file mode 100644
index 00000000..8470882a
--- /dev/null
+++ b/scm/device_settings/tests/api_general_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def general_settings_api(client):
+ return client.device_settings.GeneralSettingsApi(client.device_settings.api_client)
+
+
+def test_list_general_settings(general_settings_api):
+ """Test listing general settings (singleton per folder)."""
+ response = general_settings_api.list_general_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} general settings items")
+
+
+def test_get_general_settings_by_id(general_settings_api):
+ """Test getting general settings by ID."""
+ response = general_settings_api.list_general_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = general_settings_api.get_general_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got general settings by ID: {obj.id}")
+
+
+def test_update_general_settings(general_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = general_settings_api.list_general_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = general_settings_api.update_general_settings_by_id(
+ id=existing.id,
+ general_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated general settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_high_availability_devices_test.py b/scm/device_settings/tests/api_high_availability_devices_test.py
new file mode 100644
index 00000000..be4cb1ef
--- /dev/null
+++ b/scm/device_settings/tests/api_high_availability_devices_test.py
@@ -0,0 +1,35 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def high_availability_devices_api(client):
+ return client.device_settings.HighAvailabilityDevicesApi(client.device_settings.api_client)
+
+
+def test_list_ha_devices(high_availability_devices_api):
+ """Test listing high availability devices (List only - no Get/Update/Delete)."""
+ try:
+ response = high_availability_devices_api.list_ha_devices(folder=TARGET_FOLDER)
+ except Exception as e:
+ # The API may return an empty array [] which can cause deserialization issues
+ if "cannot unmarshal" in str(e) or "validation error" in str(e).lower():
+ pytest.skip("No HA devices configured (API returns empty array)")
+ raise
+ assert response is not None
+ logger.info("Successfully listed high availability devices")
diff --git a/scm/device_settings/tests/api_login_banner_settings_test.py b/scm/device_settings/tests/api_login_banner_settings_test.py
new file mode 100644
index 00000000..29eb36ea
--- /dev/null
+++ b/scm/device_settings/tests/api_login_banner_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def login_banner_settings_api(client):
+ return client.device_settings.LoginBannerSettingsApi(client.device_settings.api_client)
+
+
+def test_list_login_banner_settings(login_banner_settings_api):
+ """Test listing login banner settings (singleton per folder)."""
+ response = login_banner_settings_api.list_login_banner_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} login banner settings items")
+
+
+def test_get_login_banner_settings_by_id(login_banner_settings_api):
+ """Test getting login banner settings by ID."""
+ response = login_banner_settings_api.list_login_banner_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = login_banner_settings_api.get_login_banner_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got login banner settings by ID: {obj.id}")
+
+
+def test_update_login_banner_settings(login_banner_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = login_banner_settings_api.list_login_banner_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = login_banner_settings_api.update_login_banner_settings_by_id(
+ id=existing.id,
+ motd_banner_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated login banner settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_management_interface_settings_test.py b/scm/device_settings/tests/api_management_interface_settings_test.py
new file mode 100644
index 00000000..004d075a
--- /dev/null
+++ b/scm/device_settings/tests/api_management_interface_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def management_interface_settings_api(client):
+ return client.device_settings.ManagementInterfaceSettingsApi(client.device_settings.api_client)
+
+
+def test_list_management_interface_settings(management_interface_settings_api):
+ """Test listing management interface settings (singleton per folder)."""
+ response = management_interface_settings_api.list_management_interface_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} management interface settings items")
+
+
+def test_get_management_interface_settings_by_id(management_interface_settings_api):
+ """Test getting management interface settings by ID."""
+ response = management_interface_settings_api.list_management_interface_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = management_interface_settings_api.get_management_interface_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got management interface settings by ID: {obj.id}")
+
+
+def test_update_management_interface_settings(management_interface_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = management_interface_settings_api.list_management_interface_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = management_interface_settings_api.update_management_interface_settings_by_id(
+ id=existing.id,
+ management_interface=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated management interface settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_service_route_settings_test.py b/scm/device_settings/tests/api_service_route_settings_test.py
new file mode 100644
index 00000000..b4f895dd
--- /dev/null
+++ b/scm/device_settings/tests/api_service_route_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def service_route_settings_api(client):
+ return client.device_settings.ServiceRouteSettingsApi(client.device_settings.api_client)
+
+
+def test_list_service_route_settings(service_route_settings_api):
+ """Test listing service route settings (singleton per folder)."""
+ response = service_route_settings_api.list_service_route_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} service route settings items")
+
+
+def test_get_service_route_settings_by_id(service_route_settings_api):
+ """Test getting service route settings by ID."""
+ response = service_route_settings_api.list_service_route_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = service_route_settings_api.get_service_route_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got service route settings by ID: {obj.id}")
+
+
+def test_update_service_route_settings(service_route_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = service_route_settings_api.list_service_route_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = service_route_settings_api.update_service_route_settings_by_id(
+ id=existing.id,
+ service_route=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated service route settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_service_settings_test.py b/scm/device_settings/tests/api_service_settings_test.py
new file mode 100644
index 00000000..3d7948fc
--- /dev/null
+++ b/scm/device_settings/tests/api_service_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def service_settings_api(client):
+ return client.device_settings.ServiceSettingsApi(client.device_settings.api_client)
+
+
+def test_list_service_settings(service_settings_api):
+ """Test listing service settings (singleton per folder)."""
+ response = service_settings_api.list_service_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} service settings items")
+
+
+def test_get_service_settings_by_id(service_settings_api):
+ """Test getting service settings by ID."""
+ response = service_settings_api.list_service_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = service_settings_api.get_service_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got service settings by ID: {obj.id}")
+
+
+def test_update_service_settings(service_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = service_settings_api.list_service_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = service_settings_api.update_service_settings_by_id(
+ id=existing.id,
+ service_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated service settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_session_settings_test.py b/scm/device_settings/tests/api_session_settings_test.py
new file mode 100644
index 00000000..6655c9ce
--- /dev/null
+++ b/scm/device_settings/tests/api_session_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def session_settings_api(client):
+ return client.device_settings.SessionSettingsApi(client.device_settings.api_client)
+
+
+def test_list_session_settings(session_settings_api):
+ """Test listing session settings (singleton per folder)."""
+ response = session_settings_api.list_session_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} session settings items")
+
+
+def test_get_session_settings_by_id(session_settings_api):
+ """Test getting session settings by ID."""
+ response = session_settings_api.list_session_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = session_settings_api.get_session_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got session settings by ID: {obj.id}")
+
+
+def test_update_session_settings(session_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = session_settings_api.list_session_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = session_settings_api.update_session_settings_by_id(
+ id=existing.id,
+ session_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated session settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_session_timeouts_settings_test.py b/scm/device_settings/tests/api_session_timeouts_settings_test.py
new file mode 100644
index 00000000..5626537f
--- /dev/null
+++ b/scm/device_settings/tests/api_session_timeouts_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def session_timeouts_settings_api(client):
+ return client.device_settings.SessionTimeoutsSettingsApi(client.device_settings.api_client)
+
+
+def test_list_session_timeouts_settings(session_timeouts_settings_api):
+ """Test listing session timeouts settings (singleton per folder)."""
+ response = session_timeouts_settings_api.list_session_timeouts_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} session timeouts settings items")
+
+
+def test_get_session_timeouts_settings_by_id(session_timeouts_settings_api):
+ """Test getting session timeouts settings by ID."""
+ response = session_timeouts_settings_api.list_session_timeouts_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = session_timeouts_settings_api.get_session_timeouts_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got session timeouts settings by ID: {obj.id}")
+
+
+def test_update_session_timeouts_settings(session_timeouts_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = session_timeouts_settings_api.list_session_timeouts_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = session_timeouts_settings_api.update_session_timeouts_settings_by_id(
+ id=existing.id,
+ session_timeouts=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated session timeouts settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_tcp_settings_test.py b/scm/device_settings/tests/api_tcp_settings_test.py
new file mode 100644
index 00000000..4a4bdb70
--- /dev/null
+++ b/scm/device_settings/tests/api_tcp_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def tcp_settings_api(client):
+ return client.device_settings.TCPSettingsApi(client.device_settings.api_client)
+
+
+def test_list_tcp_settings(tcp_settings_api):
+ """Test listing TCP settings (singleton per folder)."""
+ response = tcp_settings_api.list_tcp_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} TCP settings items")
+
+
+def test_get_tcp_settings_by_id(tcp_settings_api):
+ """Test getting TCP settings by ID."""
+ response = tcp_settings_api.list_tcp_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = tcp_settings_api.get_tcp_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got TCP settings by ID: {obj.id}")
+
+
+def test_update_tcp_settings(tcp_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = tcp_settings_api.list_tcp_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = tcp_settings_api.update_tcp_settings_by_id(
+ id=existing.id,
+ tcp_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated TCP settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_update_schedule_settings_test.py b/scm/device_settings/tests/api_update_schedule_settings_test.py
new file mode 100644
index 00000000..976ab186
--- /dev/null
+++ b/scm/device_settings/tests/api_update_schedule_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def update_schedule_settings_api(client):
+ return client.device_settings.UpdateScheduleSettingsApi(client.device_settings.api_client)
+
+
+def test_list_update_schedule_settings(update_schedule_settings_api):
+ """Test listing update schedule settings (singleton per folder)."""
+ response = update_schedule_settings_api.list_update_schedule_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} update schedule settings items")
+
+
+def test_get_update_schedule_settings_by_id(update_schedule_settings_api):
+ """Test getting update schedule settings by ID."""
+ response = update_schedule_settings_api.list_update_schedule_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = update_schedule_settings_api.get_update_schedule_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got update schedule settings by ID: {obj.id}")
+
+
+def test_update_update_schedule_settings(update_schedule_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = update_schedule_settings_api.list_update_schedule_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = update_schedule_settings_api.update_update_schedule_settings_by_id(
+ id=existing.id,
+ update_schedule=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated update schedule settings (no-op): {updated.id}")
diff --git a/scm/device_settings/tests/api_vpn_settings_test.py b/scm/device_settings/tests/api_vpn_settings_test.py
new file mode 100644
index 00000000..2362c197
--- /dev/null
+++ b/scm/device_settings/tests/api_vpn_settings_test.py
@@ -0,0 +1,56 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def vpn_settings_api(client):
+ return client.device_settings.VPNSettingsApi(client.device_settings.api_client)
+
+
+def test_list_vpn_settings(vpn_settings_api):
+ """Test listing VPN settings (singleton per folder)."""
+ response = vpn_settings_api.list_vpn_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ logger.info(f"Listed {len(response)} VPN settings items")
+
+
+def test_get_vpn_settings_by_id(vpn_settings_api):
+ """Test getting VPN settings by ID."""
+ response = vpn_settings_api.list_vpn_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to get")
+ obj = vpn_settings_api.get_vpn_settings_by_id(id=response[0].id)
+ assert obj is not None
+ assert obj.id == response[0].id
+ logger.info(f"Got VPN settings by ID: {obj.id}")
+
+
+def test_update_vpn_settings(vpn_settings_api):
+ """No-op update: get existing settings and update with same data."""
+ response = vpn_settings_api.list_vpn_settings(folder=TARGET_FOLDER)
+ assert response is not None
+ if not response or len(response) == 0:
+ pytest.skip("No items to update")
+ existing = response[0]
+ updated = vpn_settings_api.update_vpn_settings_by_id(
+ id=existing.id,
+ vpn_settings=existing,
+ )
+ assert updated is not None
+ logger.info(f"Updated VPN settings (no-op): {updated.id}")
diff --git a/scm/error_parser.py b/scm/error_parser.py
new file mode 100644
index 00000000..1a8e3250
--- /dev/null
+++ b/scm/error_parser.py
@@ -0,0 +1,457 @@
+"""
+Error parsing utilities for SCM SDK exceptions.
+
+Refactored to use structured error data with comprehensive exception hierarchy.
+Uses a two-level mapping strategy for accurate exception classification.
+"""
+
+import json
+from typing import Any, Dict, Optional, Type, Union
+
+from scm.exceptions import (
+ # Base exceptions
+ ScmException,
+ ClientError,
+ ServerError,
+
+ # Authentication errors (401)
+ AuthenticationError,
+ NotAuthenticatedError,
+ InvalidCredentialError,
+ KeyExpiredError,
+
+ # Authorization errors (403)
+ AuthorizationError,
+
+ # Bad request errors (400)
+ BadRequestError,
+ InvalidObjectError,
+ MissingQueryParameterError,
+ InvalidQueryParameterError,
+ MalformedCommandError,
+
+ # Not found errors (404)
+ NotFoundError,
+ ObjectNotPresentError,
+
+ # Conflict errors (409)
+ ConflictError,
+ NameNotUniqueError,
+ ObjectNotUniqueError,
+ ReferenceNotZeroError,
+
+ # Other client errors
+ MethodNotAllowedError,
+ RequestTimeoutError,
+ TooManyRequestsError,
+ SessionTimedOutError,
+
+ # Server errors (5xx)
+ InternalServerError,
+ BadGatewayError,
+ ServiceUnavailableError,
+ GatewayTimeoutError,
+)
+
+
+class ErrorHandler:
+ """Centralized error handling with comprehensive exception hierarchy."""
+
+ # Map HTTP status codes to base exception classes
+ STATUS_CODE_MAP: Dict[int, Type[ScmException]] = {
+ # 4xx Client Errors
+ 400: BadRequestError,
+ 401: AuthenticationError,
+ 403: AuthorizationError,
+ 404: NotFoundError,
+ 405: MethodNotAllowedError,
+ 408: RequestTimeoutError,
+ 409: ConflictError,
+ 429: TooManyRequestsError,
+
+ # 5xx Server Errors
+ 500: InternalServerError,
+ 502: BadGatewayError,
+ 503: ServiceUnavailableError,
+ 504: GatewayTimeoutError,
+ }
+
+ # Map error codes to specific exception classes
+ # Supports both direct mapping and nested mapping by errorType/message
+ ERROR_CODE_MAP: Dict[str, Union[Type[ScmException], Dict[str, Type[ScmException]]]] = {
+ # SCM API error codes
+ "API_I00013": {
+ "object not present": ObjectNotPresentError,
+ "operation impossible": ObjectNotPresentError,
+ "object already exists": NameNotUniqueError,
+ "object_already_exists": NameNotUniqueError,
+ "OBJECT_ALREADY_EXISTS": NameNotUniqueError, # Nested errors[].type format
+ "non_zero_refs": ReferenceNotZeroError,
+ "reference not zero": ReferenceNotZeroError,
+ "default": InvalidObjectError, # Fallback for other API_I00013 messages
+ },
+ "API_I00035": {
+ "resource not present": ObjectNotPresentError,
+ "default": InvalidObjectError, # Fallback for other messages
+ },
+
+ # Legacy error codes
+ "E003": {
+ "Missing Query Parameter": MissingQueryParameterError,
+ "Invalid Query Parameter": InvalidQueryParameterError,
+ "Invalid Object": InvalidObjectError,
+ "Malformed Command": MalformedCommandError,
+ "default": BadRequestError,
+ },
+ "E005": ObjectNotPresentError,
+ "E006": NameNotUniqueError,
+ "E009": ReferenceNotZeroError,
+
+ # Authentication error codes
+ "E001": NotAuthenticatedError,
+ "E002": InvalidCredentialError,
+ "E011": KeyExpiredError,
+ "E016": SessionTimedOutError,
+
+ # Authorization error codes
+ "E004": AuthorizationError,
+
+ # Server error codes
+ "E007": InternalServerError,
+ "E008": ServiceUnavailableError,
+ }
+
+ # Map message patterns to exception classes (for cases without error codes)
+ MESSAGE_PATTERN_MAP: Dict[str, Type[ScmException]] = {
+ # Authentication patterns
+ "not authenticated": NotAuthenticatedError,
+ "authentication failed": NotAuthenticatedError,
+ "invalid credentials": InvalidCredentialError,
+ "invalid client": InvalidCredentialError,
+ "unauthorized": NotAuthenticatedError,
+ "token expired": KeyExpiredError,
+ "jwt expired": KeyExpiredError,
+ "session expired": SessionTimedOutError,
+ "session timed out": SessionTimedOutError,
+
+ # Authorization patterns
+ "forbidden": AuthorizationError,
+ "access denied": AuthorizationError,
+ "insufficient privileges": AuthorizationError,
+ "permission denied": AuthorizationError,
+
+ # Not found patterns
+ "not found": ObjectNotPresentError,
+ "does not exist": ObjectNotPresentError,
+ "object not present": ObjectNotPresentError,
+
+ # Conflict patterns
+ "already exists": NameNotUniqueError,
+ "duplicate": NameNotUniqueError,
+ "name is not unique": NameNotUniqueError,
+ "reference not zero": ReferenceNotZeroError,
+ "still referenced": ReferenceNotZeroError,
+
+ # Bad request patterns
+ "invalid object": InvalidObjectError,
+ "validation failed": InvalidObjectError,
+ "missing parameter": MissingQueryParameterError,
+ "invalid parameter": InvalidQueryParameterError,
+ "malformed": MalformedCommandError,
+
+ # Rate limiting
+ "rate limit": TooManyRequestsError,
+ "too many requests": TooManyRequestsError,
+
+ # Server errors
+ "internal server error": InternalServerError,
+ "service unavailable": ServiceUnavailableError,
+ "bad gateway": BadGatewayError,
+ "gateway timeout": GatewayTimeoutError,
+ }
+
+ @classmethod
+ def parse_exception(
+ cls,
+ exception_or_status,
+ body: Optional[str] = None,
+ reason: Optional[str] = None,
+ ) -> ScmException:
+ """
+ Parse an API exception and return the appropriate custom exception.
+
+ Args:
+ exception_or_status: Either an ApiException object or HTTP status code
+ body: Optional JSON response body (if status code provided)
+ reason: Optional reason phrase (if status code provided)
+
+ Returns:
+ ScmException: Appropriate subclass based on error details
+
+ Examples:
+ # From caught exception
+ try:
+ api.get_by_id(id="...")
+ except NotFoundException as e:
+ custom_exc = ErrorHandler.parse_exception(e)
+
+ # From status/body/reason
+ custom_exc = ErrorHandler.parse_exception(404, '{"message": "..."}', "Not Found")
+ """
+ # Extract status, body, reason from exception or parameters
+ if hasattr(exception_or_status, 'status'):
+ # It's an ApiException object
+ status = exception_or_status.status
+ body = exception_or_status.body
+ reason = exception_or_status.reason
+
+ # Try to get structured error data from Pydantic model
+ error_data = cls._extract_error_data(exception_or_status)
+ else:
+ # It's a status code
+ status = exception_or_status
+ try:
+ error_data = json.loads(body) if body else {}
+ except (json.JSONDecodeError, TypeError):
+ # Not valid JSON, return generic exception
+ return ScmException(
+ reason or f"HTTP {status}",
+ error_code=str(status),
+ http_status_code=status
+ )
+
+ # Extract error details from response
+ error_info = cls._extract_error_info(error_data, status, reason)
+
+ # Map to appropriate exception class
+ exception_cls = cls._map_exception_class(
+ status=status,
+ error_code=error_info['error_code'],
+ error_type=error_info['error_type'],
+ message=error_info['message'],
+ )
+
+ # Extract retry_after if present (for rate limiting and service unavailable)
+ retry_after = None
+ if status in (429, 503):
+ retry_after = error_info['details'].get('retry_after')
+
+ # Instantiate exception with all available info
+ return exception_cls(
+ message=error_info['message'],
+ error_code=error_info['error_code'],
+ http_status_code=status,
+ details=error_info['details'],
+ # Include object_id/object_name if available
+ object_id=error_info.get('object_id'),
+ object_name=error_info.get('object_name'),
+ # Include parameter info for query parameter errors
+ parameter_name=error_info.get('parameter_name'),
+ parameter_value=error_info.get('parameter_value'),
+ # Include retry_after for rate limit and service unavailable
+ retry_after=retry_after,
+ # Include references for ReferenceNotZeroError
+ references=error_info.get('references'),
+ # Include errors list for InvalidObjectError
+ errors=error_info.get('errors'),
+ )
+
+ @classmethod
+ def _extract_error_data(cls, exception) -> Dict[str, Any]:
+ """Extract error data from exception's data attribute (Pydantic model)."""
+ if hasattr(exception, 'data') and exception.data:
+ # Data is a Pydantic model, convert to dict
+ if hasattr(exception.data, 'model_dump'):
+ return exception.data.model_dump()
+ elif hasattr(exception.data, 'dict'):
+ return exception.data.dict()
+ else:
+ # Try to access as dict-like object
+ return dict(exception.data) if exception.data else {}
+ else:
+ # Try to parse body as JSON
+ try:
+ return json.loads(exception.body) if exception.body else {}
+ except (json.JSONDecodeError, TypeError, AttributeError):
+ return {}
+
+ @classmethod
+ def _extract_error_info(cls, error_data: Dict[str, Any], status: int, reason: str) -> Dict[str, Any]:
+ """
+ Extract structured error information from API response.
+
+ Returns dict with keys:
+ - error_code: str
+ - message: str
+ - error_type: str (from details.errorType)
+ - details: dict
+ - object_id: Optional[str]
+ - object_name: Optional[str]
+ - parameter_name: Optional[str]
+ - parameter_value: Optional[Any]
+ - references: Optional[List[Dict]]
+ - errors: Optional[List[Dict]]
+ """
+ # Handle GenericError model structure (common format)
+ if 'errors' in error_data and isinstance(error_data['errors'], list) and len(error_data['errors']) > 0:
+ first_error = error_data['errors'][0]
+ error_code = first_error.get('code', '')
+ message = first_error.get('message', reason or f"HTTP {status}")
+ details = first_error.get('details', {})
+ else:
+ # Standard error format
+ error_code = error_data.get('code', '')
+ message = error_data.get('message', reason or f"HTTP {status}")
+ details = error_data.get('details', {})
+
+ # Ensure details is a dict (API sometimes returns a string)
+ if not isinstance(details, dict):
+ details = {}
+
+ # Extract errorType from details (structured field provided by API)
+ error_type = details.get('errorType', '')
+
+ # Check for nested error structure
+ # Some APIs return errorType="Operation Failed" with specific type in errors[].type
+ if 'errors' in details:
+ errors_list = details.get('errors', [])
+ if isinstance(errors_list, list) and len(errors_list) > 0:
+ if isinstance(errors_list[0], dict):
+ nested_type = errors_list[0].get('type', '')
+ # Prefer nested type if it's more specific than generic errorType
+ if nested_type and (not error_type or error_type in ('Operation Failed', 'Generic Error')):
+ error_type = nested_type
+
+ # Extract object_id and object_name from details if available
+ object_id = details.get('id') or details.get('object_id')
+ object_name = details.get('name') or details.get('object_name')
+
+ # Extract parameter info from details
+ parameter_name = details.get('parameter') or details.get('param')
+ parameter_value = details.get('value')
+
+ # Extract references for ReferenceNotZeroError
+ references = details.get('references', [])
+
+ # Extract validation errors for InvalidObjectError
+ errors = details.get('errors', [])
+
+ return {
+ 'error_code': error_code,
+ 'message': message,
+ 'error_type': error_type,
+ 'details': details,
+ 'object_id': object_id,
+ 'object_name': object_name,
+ 'parameter_name': parameter_name,
+ 'parameter_value': parameter_value,
+ 'references': references if isinstance(references, list) else [],
+ 'errors': errors if isinstance(errors, list) else [],
+ }
+
+ @classmethod
+ def _map_exception_class(
+ cls,
+ status: int,
+ error_code: str,
+ error_type: str,
+ message: str,
+ ) -> Type[ScmException]:
+ """
+ Map error details to appropriate exception class using multi-level strategy.
+
+ Priority:
+ 1. Error code + error type match (most specific)
+ 2. Error code match (general)
+ 3. Message pattern match (for cases without error codes)
+ 4. HTTP status code match
+ 5. Default to generic ClientError/ServerError based on status range
+ """
+ # Get base exception class from HTTP status code
+ exception_cls = cls.STATUS_CODE_MAP.get(status)
+
+ # If no specific mapping, use generic ClientError or ServerError
+ if not exception_cls:
+ if 400 <= status < 500:
+ exception_cls = ClientError
+ elif 500 <= status < 600:
+ exception_cls = ServerError
+ else:
+ exception_cls = ScmException
+
+ # Refine based on error code
+ if error_code in cls.ERROR_CODE_MAP:
+ code_mapping = cls.ERROR_CODE_MAP[error_code]
+
+ # If mapping is a dict, match by errorType or message
+ if isinstance(code_mapping, dict):
+ # Try case-insensitive errorType match
+ if error_type:
+ error_type_lower = error_type.lower()
+ code_mapping_lower = {k.lower(): v for k, v in code_mapping.items()}
+ if error_type_lower in code_mapping_lower:
+ exception_cls = code_mapping_lower[error_type_lower]
+ return exception_cls
+
+ # Try exact message match
+ if message in code_mapping:
+ exception_cls = code_mapping[message]
+ return exception_cls
+
+ # Try case-insensitive message substring match
+ message_lower = message.lower()
+ for key, exc_class in code_mapping.items():
+ if key != 'default' and key.lower() in message_lower:
+ exception_cls = exc_class
+ return exception_cls
+
+ # Try default fallback
+ if 'default' in code_mapping:
+ exception_cls = code_mapping['default']
+ return exception_cls
+
+ # Use base exception from status code
+ return exception_cls
+ else:
+ # Direct mapping
+ return code_mapping
+
+ # Try message pattern matching (for cases without error codes)
+ if message:
+ message_lower = message.lower()
+ for pattern, exc_class in cls.MESSAGE_PATTERN_MAP.items():
+ if pattern in message_lower:
+ return exc_class
+
+ # Use base exception from status code
+ return exception_cls
+
+
+# Backward compatibility: keep parse_scm_error function
+def parse_scm_error(exception_or_status, body: Optional[str] = None, reason: Optional[str] = None) -> ScmException:
+ """
+ Parse an API exception and return the appropriate custom exception.
+
+ This function is maintained for backward compatibility.
+ New code should use ErrorHandler.parse_exception() directly.
+
+ Args:
+ exception_or_status: Either an ApiException object or HTTP status code
+ body: Optional JSON response body (if status code provided)
+ reason: Optional reason phrase (if status code provided)
+
+ Returns:
+ ScmException: Appropriate subclass based on error details
+
+ Examples:
+ # From caught exception
+ try:
+ addresses_api.get_addresses_by_id(id=created_obj.id)
+ except NotFoundException as e:
+ custom_exc = parse_scm_error(e)
+ assert isinstance(custom_exc, ObjectNotPresentError)
+
+ # From raw status/body/reason
+ custom_exc = parse_scm_error(404, '{"message": "..."}', "Not Found")
+ """
+ return ErrorHandler.parse_exception(exception_or_status, body, reason)
diff --git a/scm/exceptions.py b/scm/exceptions.py
new file mode 100644
index 00000000..30840ede
--- /dev/null
+++ b/scm/exceptions.py
@@ -0,0 +1,659 @@
+"""
+SCM Custom Exceptions - Comprehensive error handling for SCM SDK.
+
+Exception Hierarchy:
+ ScmException (base)
+ ├── ClientError (4xx)
+ │ ├── AuthenticationError (401)
+ │ │ ├── NotAuthenticatedError
+ │ │ ├── InvalidCredentialError
+ │ │ └── KeyExpiredError
+ │ ├── AuthorizationError (403)
+ │ ├── BadRequestError (400)
+ │ │ ├── InvalidObjectError
+ │ │ ├── MissingQueryParameterError
+ │ │ ├── InvalidQueryParameterError
+ │ │ └── MalformedCommandError
+ │ ├── NotFoundError (404)
+ │ │ └── ObjectNotPresentError
+ │ ├── ConflictError (409)
+ │ │ ├── NameNotUniqueError
+ │ │ ├── ObjectNotUniqueError
+ │ │ └── ReferenceNotZeroError
+ │ ├── MethodNotAllowedError (405)
+ │ ├── RequestTimeoutError (408)
+ │ ├── TooManyRequestsError (429)
+ │ └── SessionTimedOutError
+ └── ServerError (5xx)
+ ├── InternalServerError (500)
+ ├── BadGatewayError (502)
+ ├── ServiceUnavailableError (503)
+ └── GatewayTimeoutError (504)
+
+These exceptions are automatically raised via decorators. No manual parsing required.
+
+Example:
+ from scm.exceptions import NameNotUniqueError, ObjectNotPresentError
+
+ try:
+ response = api.create_addresses(addresses=data)
+ except NameNotUniqueError as e:
+ print(f"Name '{e.object_name}' already exists")
+ print(f"Error code: {e.error_code}")
+ except ObjectNotPresentError as e:
+ print(f"Object not found: {e.object_id}")
+"""
+
+from typing import Optional, List, Dict, Any
+
+
+# =============================================================================
+# BASE EXCEPTIONS
+# =============================================================================
+
+class ScmException(Exception):
+ """Base exception for all SCM-specific errors with structured attributes."""
+
+ def __init__(
+ self,
+ message: str,
+ error_code: Optional[str] = None,
+ http_status_code: Optional[int] = None,
+ details: Optional[Dict[str, Any]] = None,
+ **kwargs
+ ):
+ """
+ Initialize SCM exception.
+
+ Args:
+ message: Human-readable error message
+ error_code: API error code (e.g., "API_I00013", "E006")
+ http_status_code: HTTP status code (e.g., 400, 404, 409)
+ details: Additional error details from API response
+ **kwargs: Additional attributes (stored for subclasses)
+ """
+ super().__init__(message)
+ self.message = message
+ self.error_code = error_code
+ self.http_status_code = http_status_code
+ self.details = details or {}
+
+ # Store any additional kwargs as attributes
+ for key, value in kwargs.items():
+ setattr(self, key, value)
+
+ def __str__(self):
+ """Return string representation including error codes."""
+ parts = [self.message]
+ if self.error_code:
+ parts.append(f"[{self.error_code}]")
+ if self.http_status_code:
+ parts.append(f"(HTTP {self.http_status_code})")
+ return " ".join(parts)
+
+
+class ClientError(ScmException):
+ """Base class for all 4xx client errors."""
+ pass
+
+
+class ServerError(ScmException):
+ """Base class for all 5xx server errors."""
+ pass
+
+
+# =============================================================================
+# AUTHENTICATION ERRORS (401)
+# =============================================================================
+
+class AuthenticationError(ClientError):
+ """
+ Base class for authentication errors (401).
+
+ Raised when authentication fails or credentials are invalid.
+ """
+ pass
+
+
+class NotAuthenticatedError(AuthenticationError):
+ """
+ Raised when request is not authenticated.
+
+ HTTP Status: 401 Unauthorized
+
+ Common causes:
+ - Missing authentication credentials
+ - Invalid or expired token
+ - Token not provided
+ """
+ pass
+
+
+class InvalidCredentialError(AuthenticationError):
+ """
+ Raised when credentials are invalid.
+
+ HTTP Status: 401 Unauthorized
+
+ Common causes:
+ - Invalid client_id or client_secret
+ - Incorrect username/password
+ - Malformed credentials
+ """
+ pass
+
+
+class KeyExpiredError(AuthenticationError):
+ """
+ Raised when API key or token has expired.
+
+ HTTP Status: 401 Unauthorized
+
+ Common causes:
+ - JWT token expired
+ - API key expired
+ - Session expired
+ """
+ pass
+
+
+# =============================================================================
+# AUTHORIZATION ERRORS (403)
+# =============================================================================
+
+class AuthorizationError(ClientError):
+ """
+ Raised when user lacks permission for the requested operation.
+
+ HTTP Status: 403 Forbidden
+
+ Common causes:
+ - Insufficient privileges
+ - Resource access denied
+ - Operation not permitted for user role
+ """
+ pass
+
+
+# =============================================================================
+# BAD REQUEST ERRORS (400)
+# =============================================================================
+
+class BadRequestError(ClientError):
+ """
+ Base class for bad request errors (400).
+
+ Raised when request is malformed or contains invalid data.
+ """
+ pass
+
+
+class InvalidObjectError(BadRequestError):
+ """
+ Raised when object data fails validation.
+
+ HTTP Status: 400 Bad Request
+ API Error Codes: E003, API_I00035
+
+ Attributes:
+ errors: List of validation errors
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ errors: Optional[List[Dict]] = None,
+ **kwargs
+ ):
+ """
+ Initialize InvalidObjectError.
+
+ Args:
+ message: Error message from API
+ errors: List of validation errors
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.errors = errors or []
+
+ # Build message if not provided
+ if not message:
+ error_count = len(self.errors)
+ if error_count > 0:
+ message = f"Object validation failed: {error_count} error(s)"
+ else:
+ message = "Object validation failed"
+
+ super().__init__(message, **kwargs)
+
+
+class MissingQueryParameterError(BadRequestError):
+ """
+ Raised when a required query parameter is missing.
+
+ HTTP Status: 400 Bad Request
+ API Error Code: E003 (with message="Missing Query Parameter")
+
+ Attributes:
+ parameter_name: Name of the missing parameter
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ parameter_name: Optional[str] = None,
+ **kwargs
+ ):
+ """
+ Initialize MissingQueryParameterError.
+
+ Args:
+ message: Error message from API
+ parameter_name: Name of the missing parameter
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.parameter_name = parameter_name
+
+ # Build message if not provided
+ if not message:
+ if parameter_name:
+ message = f"Missing required parameter: {parameter_name}"
+ else:
+ message = "Missing required query parameter"
+
+ super().__init__(message, **kwargs)
+
+
+class InvalidQueryParameterError(BadRequestError):
+ """
+ Raised when a query parameter has an invalid value.
+
+ HTTP Status: 400 Bad Request
+
+ Attributes:
+ parameter_name: Name of the invalid parameter
+ parameter_value: Invalid value provided
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ parameter_name: Optional[str] = None,
+ parameter_value: Optional[Any] = None,
+ **kwargs
+ ):
+ """
+ Initialize InvalidQueryParameterError.
+
+ Args:
+ message: Error message from API
+ parameter_name: Name of the invalid parameter
+ parameter_value: Invalid value provided
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.parameter_name = parameter_name
+ self.parameter_value = parameter_value
+
+ # Build message if not provided
+ if not message:
+ if parameter_name and parameter_value is not None:
+ message = f"Invalid value '{parameter_value}' for parameter '{parameter_name}'"
+ elif parameter_name:
+ message = f"Invalid value for parameter '{parameter_name}'"
+ else:
+ message = "Invalid query parameter"
+
+ super().__init__(message, **kwargs)
+
+
+class MalformedCommandError(BadRequestError):
+ """
+ Raised when command syntax is malformed.
+
+ HTTP Status: 400 Bad Request
+
+ Common causes:
+ - Invalid JSON structure
+ - Malformed request body
+ - Incorrect API call format
+ """
+ pass
+
+
+# =============================================================================
+# NOT FOUND ERRORS (404)
+# =============================================================================
+
+class NotFoundError(ClientError):
+ """
+ Base class for not found errors (404).
+
+ Raised when requested resource does not exist.
+ """
+ pass
+
+
+class ObjectNotPresentError(NotFoundError):
+ """
+ Raised when an object is not found.
+
+ HTTP Status: 404 Not Found
+ API Error Codes: E005, API_I00013 (with errorType="object not present")
+
+ Attributes:
+ object_id: ID of the object that was not found
+ object_name: Name of the object that was not found
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ object_id: Optional[str] = None,
+ object_name: Optional[str] = None,
+ **kwargs
+ ):
+ """
+ Initialize ObjectNotPresentError.
+
+ Args:
+ message: Error message from API
+ object_id: ID of the missing object
+ object_name: Name of the missing object
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.object_id = object_id
+ self.object_name = object_name
+
+ # Build message if not provided
+ if not message:
+ if object_id:
+ message = f"Object with ID '{object_id}' not found"
+ elif object_name:
+ message = f"Object '{object_name}' not found"
+ else:
+ message = "Object not found"
+
+ super().__init__(message, **kwargs)
+
+
+# =============================================================================
+# CONFLICT ERRORS (409)
+# =============================================================================
+
+class ConflictError(ClientError):
+ """
+ Base class for conflict errors (409).
+
+ Raised when request conflicts with current state.
+ """
+ pass
+
+
+class NameNotUniqueError(ConflictError):
+ """
+ Raised when an object name already exists in the same container.
+
+ HTTP Status: 409 Conflict
+ API Error Codes: E006, API_I00013 (with errorType="object already exists")
+
+ Attributes:
+ object_name: Name of the object that already exists
+ container: Container where duplicate was found (folder/snippet/device)
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ object_name: Optional[str] = None,
+ container: Optional[str] = None,
+ **kwargs
+ ):
+ """
+ Initialize NameNotUniqueError.
+
+ Args:
+ message: Error message from API
+ object_name: Name of the duplicate object
+ container: Container (folder/snippet/device)
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.object_name = object_name
+ self.container = container
+
+ # Build message if not provided
+ if not message:
+ if object_name and container:
+ message = f"Object '{object_name}' already exists in {container}"
+ elif object_name:
+ message = f"Object '{object_name}' already exists"
+ else:
+ message = "Object name is not unique"
+
+ super().__init__(message, **kwargs)
+
+
+class ObjectNotUniqueError(ConflictError):
+ """
+ Raised when object is not unique (broader than name).
+
+ HTTP Status: 409 Conflict
+
+ Similar to NameNotUniqueError but applies to other uniqueness constraints
+ (e.g., IP address, MAC address, etc.)
+ """
+ pass
+
+
+class ReferenceNotZeroError(ConflictError):
+ """
+ Raised when attempting to delete an object that is still referenced by other objects.
+
+ HTTP Status: 409 Conflict
+ API Error Codes: E009, API_I00013 (with errorType="reference not zero")
+
+ Attributes:
+ object_name: Name of the object that cannot be deleted
+ references: List of objects that reference this object
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ object_name: Optional[str] = None,
+ references: Optional[List[Dict]] = None,
+ **kwargs
+ ):
+ """
+ Initialize ReferenceNotZeroError.
+
+ Args:
+ message: Error message from API
+ object_name: Name of the object that is still referenced
+ references: List of referencing objects
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.object_name = object_name
+ self.references = references or []
+
+ # Build message if not provided
+ if not message:
+ ref_count = len(self.references)
+ if object_name and ref_count > 0:
+ message = f"Cannot delete '{object_name}' - referenced by {ref_count} object(s)"
+ elif object_name:
+ message = f"Cannot delete '{object_name}' - still has references"
+ else:
+ message = "Object is still referenced and cannot be deleted"
+
+ super().__init__(message, **kwargs)
+
+
+# =============================================================================
+# OTHER CLIENT ERRORS
+# =============================================================================
+
+class MethodNotAllowedError(ClientError):
+ """
+ Raised when HTTP method is not allowed for the resource.
+
+ HTTP Status: 405 Method Not Allowed
+
+ Common causes:
+ - Using POST when only GET is allowed
+ - Using DELETE on a read-only resource
+ """
+ pass
+
+
+class RequestTimeoutError(ClientError):
+ """
+ Raised when request times out.
+
+ HTTP Status: 408 Request Timeout
+
+ Common causes:
+ - Request took too long to process
+ - Client didn't send complete request in time
+ """
+ pass
+
+
+class TooManyRequestsError(ClientError):
+ """
+ Raised when rate limit is exceeded.
+
+ HTTP Status: 429 Too Many Requests
+
+ Attributes:
+ retry_after: Number of seconds to wait before retrying
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ retry_after: Optional[int] = None,
+ **kwargs
+ ):
+ """
+ Initialize TooManyRequestsError.
+
+ Args:
+ message: Error message from API
+ retry_after: Seconds to wait before retrying
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.retry_after = retry_after
+
+ # Build message if not provided
+ if not message:
+ if retry_after:
+ message = f"Rate limit exceeded. Retry after {retry_after} seconds"
+ else:
+ message = "Rate limit exceeded"
+
+ super().__init__(message, **kwargs)
+
+
+class SessionTimedOutError(ClientError):
+ """
+ Raised when session has timed out.
+
+ Common causes:
+ - Session expired due to inactivity
+ - Token expired
+ """
+ pass
+
+
+# =============================================================================
+# SERVER ERRORS (5xx)
+# =============================================================================
+
+class InternalServerError(ServerError):
+ """
+ Raised when server encounters an internal error.
+
+ HTTP Status: 500 Internal Server Error
+
+ Common causes:
+ - Unexpected server condition
+ - Unhandled exception on server
+ - Server misconfiguration
+ """
+ pass
+
+
+class BadGatewayError(ServerError):
+ """
+ Raised when gateway receives invalid response from upstream server.
+
+ HTTP Status: 502 Bad Gateway
+
+ Common causes:
+ - Upstream server down
+ - Invalid response from upstream
+ - Gateway misconfiguration
+ """
+ pass
+
+
+class ServiceUnavailableError(ServerError):
+ """
+ Raised when service is temporarily unavailable.
+
+ HTTP Status: 503 Service Unavailable
+
+ Attributes:
+ retry_after: Number of seconds to wait before retrying
+
+ Common causes:
+ - Server maintenance
+ - Server overloaded
+ - Temporary outage
+ """
+
+ def __init__(
+ self,
+ message: Optional[str] = None,
+ retry_after: Optional[int] = None,
+ **kwargs
+ ):
+ """
+ Initialize ServiceUnavailableError.
+
+ Args:
+ message: Error message from API
+ retry_after: Seconds to wait before retrying
+ **kwargs: Additional parameters (error_code, http_status_code, details)
+ """
+ self.retry_after = retry_after
+
+ # Build message if not provided
+ if not message:
+ if retry_after:
+ message = f"Service unavailable. Retry after {retry_after} seconds"
+ else:
+ message = "Service temporarily unavailable"
+
+ super().__init__(message, **kwargs)
+
+
+class GatewayTimeoutError(ServerError):
+ """
+ Raised when gateway times out waiting for upstream server.
+
+ HTTP Status: 504 Gateway Timeout
+
+ Common causes:
+ - Upstream server not responding
+ - Network connectivity issues
+ - Request processing taking too long
+ """
+ pass
+
+
+# =============================================================================
+# BACKWARDS COMPATIBILITY ALIASES
+# =============================================================================
+
+# Keep old names for backwards compatibility
+APIError = ScmException # Alias for pan-scm-sdk compatibility
diff --git a/scm/identity_services/__init__.py b/scm/identity_services/__init__.py
new file mode 100644
index 00000000..375de3bc
--- /dev/null
+++ b/scm/identity_services/__init__.py
@@ -0,0 +1,125 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from scm.identity_services.api.authentication_portals_api import AuthenticationPortalsApi
+from scm.identity_services.api.authentication_profiles_api import AuthenticationProfilesApi
+from scm.identity_services.api.authentication_rules_api import AuthenticationRulesApi
+from scm.identity_services.api.authentication_sequences_api import AuthenticationSequencesApi
+from scm.identity_services.api.certificate_profiles_api import CertificateProfilesApi
+from scm.identity_services.api.certificates_api import CertificatesApi
+from scm.identity_services.api.kerberos_server_profiles_api import KerberosServerProfilesApi
+from scm.identity_services.api.ldap_server_profiles_api import LDAPServerProfilesApi
+from scm.identity_services.api.local_user_groups_api import LocalUserGroupsApi
+from scm.identity_services.api.local_users_api import LocalUsersApi
+from scm.identity_services.api.mfa_servers_api import MFAServersApi
+from scm.identity_services.api.ocsp_responders_api import OCSPRespondersApi
+from scm.identity_services.api.radius_server_profiles_api import RADIUSServerProfilesApi
+from scm.identity_services.api.saml_server_profiles_api import SAMLServerProfilesApi
+from scm.identity_services.api.scep_profiles_api import SCEPProfilesApi
+from scm.identity_services.api.tacacs_server_profiles_api import TACACSServerProfilesApi
+from scm.identity_services.api.tls_service_profiles_api import TLSServiceProfilesApi
+from scm.identity_services.api.trusted_certificate_authorities_api import TrustedCertificateAuthoritiesApi
+
+# import ApiClient
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.api_client import ApiClient
+from scm.identity_services.configuration import Configuration
+from scm.identity_services.exceptions import OpenApiException
+from scm.identity_services.exceptions import ApiTypeError
+from scm.identity_services.exceptions import ApiValueError
+from scm.identity_services.exceptions import ApiKeyError
+from scm.identity_services.exceptions import ApiAttributeError
+from scm.identity_services.exceptions import ApiException
+
+# import models into sdk package
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from scm.identity_services.models.authentication_portals_list_response import AuthenticationPortalsListResponse
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.models.authentication_profiles_list_response import AuthenticationProfilesListResponse
+from scm.identity_services.models.authentication_profiles_lockout import AuthenticationProfilesLockout
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+from scm.identity_services.models.authentication_profiles_method_cloud import AuthenticationProfilesMethodCloud
+from scm.identity_services.models.authentication_profiles_method_kerberos import AuthenticationProfilesMethodKerberos
+from scm.identity_services.models.authentication_profiles_method_ldap import AuthenticationProfilesMethodLdap
+from scm.identity_services.models.authentication_profiles_method_radius import AuthenticationProfilesMethodRadius
+from scm.identity_services.models.authentication_profiles_method_saml_idp import AuthenticationProfilesMethodSamlIdp
+from scm.identity_services.models.authentication_profiles_method_tacplus import AuthenticationProfilesMethodTacplus
+from scm.identity_services.models.authentication_profiles_multi_factor_auth import AuthenticationProfilesMultiFactorAuth
+from scm.identity_services.models.authentication_profiles_single_sign_on import AuthenticationProfilesSingleSignOn
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from scm.identity_services.models.authentication_rules_list_response import AuthenticationRulesListResponse
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from scm.identity_services.models.authentication_sequences_list_response import AuthenticationSequencesListResponse
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from scm.identity_services.models.certificate_profiles_ca_certificates_inner import CertificateProfilesCaCertificatesInner
+from scm.identity_services.models.certificate_profiles_list_response import CertificateProfilesListResponse
+from scm.identity_services.models.certificate_profiles_username_field import CertificateProfilesUsernameField
+from scm.identity_services.models.certificates_get import CertificatesGet
+from scm.identity_services.models.certificates_import import CertificatesImport
+from scm.identity_services.models.certificates_list_response import CertificatesListResponse
+from scm.identity_services.models.certificates_post import CertificatesPost
+from scm.identity_services.models.certificates_post_algorithm import CertificatesPostAlgorithm
+from scm.identity_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.identity_services.models.export_certificate_payload import ExportCertificatePayload
+from scm.identity_services.models.export_certificate_response import ExportCertificateResponse
+from scm.identity_services.models.generic_error import GenericError
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from scm.identity_services.models.kerberos_server_profiles_list_response import KerberosServerProfilesListResponse
+from scm.identity_services.models.kerberos_server_profiles_server_inner import KerberosServerProfilesServerInner
+from scm.identity_services.models.ldap_server_profiles_list_response import LDAPServerProfilesListResponse
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+from scm.identity_services.models.ldap_server_profiles_server_inner import LdapServerProfilesServerInner
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from scm.identity_services.models.local_user_groups_list_response import LocalUserGroupsListResponse
+from scm.identity_services.models.local_users import LocalUsers
+from scm.identity_services.models.local_users_list_response import LocalUsersListResponse
+from scm.identity_services.models.mfa_servers_list_response import MFAServersListResponse
+from scm.identity_services.models.mfa_servers import MfaServers
+from scm.identity_services.models.mfa_servers_mfa_vendor_type import MfaServersMfaVendorType
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_duo_security_v2 import MfaServersMfaVendorTypeDuoSecurityV2
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_okta_adaptive_v1 import MfaServersMfaVendorTypeOktaAdaptiveV1
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_ping_identity_v1 import MfaServersMfaVendorTypePingIdentityV1
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_rsa_securid_access_v1 import MfaServersMfaVendorTypeRsaSecuridAccessV1
+from scm.identity_services.models.ocsp_responders_list_response import OCSPRespondersListResponse
+from scm.identity_services.models.ocsp_responders import OcspResponders
+from scm.identity_services.models.radius_server_profiles_list_response import RADIUSServerProfilesListResponse
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+from scm.identity_services.models.radius_server_profiles_protocol import RadiusServerProfilesProtocol
+from scm.identity_services.models.radius_server_profiles_protocol_eapttls_with_pap import RadiusServerProfilesProtocolEAPTTLSWithPAP
+from scm.identity_services.models.radius_server_profiles_protocol_peapmschapv2 import RadiusServerProfilesProtocolPEAPMSCHAPv2
+from scm.identity_services.models.radius_server_profiles_server_inner import RadiusServerProfilesServerInner
+from scm.identity_services.models.rule_based_move import RuleBasedMove
+from scm.identity_services.models.saml_server_profiles_list_response import SAMLServerProfilesListResponse
+from scm.identity_services.models.scep_profiles_list_response import SCEPProfilesListResponse
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+from scm.identity_services.models.scep_profiles import ScepProfiles
+from scm.identity_services.models.scep_profiles_algorithm import ScepProfilesAlgorithm
+from scm.identity_services.models.scep_profiles_algorithm_rsa import ScepProfilesAlgorithmRsa
+from scm.identity_services.models.scep_profiles_certificate_attributes import ScepProfilesCertificateAttributes
+from scm.identity_services.models.scep_profiles_scep_challenge import ScepProfilesScepChallenge
+from scm.identity_services.models.scep_profiles_scep_challenge_dynamic import ScepProfilesScepChallengeDynamic
+from scm.identity_services.models.tacacs_server_profiles_list_response import TACACSServerProfilesListResponse
+from scm.identity_services.models.tls_service_profiles_list_response import TLSServiceProfilesListResponse
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+from scm.identity_services.models.tacacs_server_profiles_server_inner import TacacsServerProfilesServerInner
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+from scm.identity_services.models.tls_service_profiles_protocol_settings import TlsServiceProfilesProtocolSettings
+from scm.identity_services.models.trusted_certificate_authorities import TrustedCertificateAuthorities
+from scm.identity_services.models.trusted_certificate_authorities_list_response import TrustedCertificateAuthoritiesListResponse
diff --git a/scm/identity_services/api/__init__.py b/scm/identity_services/api/__init__.py
new file mode 100644
index 00000000..74253b21
--- /dev/null
+++ b/scm/identity_services/api/__init__.py
@@ -0,0 +1,22 @@
+# flake8: noqa
+
+# import apis into api package
+from scm.identity_services.api.authentication_portals_api import AuthenticationPortalsApi
+from scm.identity_services.api.authentication_profiles_api import AuthenticationProfilesApi
+from scm.identity_services.api.authentication_rules_api import AuthenticationRulesApi
+from scm.identity_services.api.authentication_sequences_api import AuthenticationSequencesApi
+from scm.identity_services.api.certificate_profiles_api import CertificateProfilesApi
+from scm.identity_services.api.certificates_api import CertificatesApi
+from scm.identity_services.api.kerberos_server_profiles_api import KerberosServerProfilesApi
+from scm.identity_services.api.ldap_server_profiles_api import LDAPServerProfilesApi
+from scm.identity_services.api.local_user_groups_api import LocalUserGroupsApi
+from scm.identity_services.api.local_users_api import LocalUsersApi
+from scm.identity_services.api.mfa_servers_api import MFAServersApi
+from scm.identity_services.api.ocsp_responders_api import OCSPRespondersApi
+from scm.identity_services.api.radius_server_profiles_api import RADIUSServerProfilesApi
+from scm.identity_services.api.saml_server_profiles_api import SAMLServerProfilesApi
+from scm.identity_services.api.scep_profiles_api import SCEPProfilesApi
+from scm.identity_services.api.tacacs_server_profiles_api import TACACSServerProfilesApi
+from scm.identity_services.api.tls_service_profiles_api import TLSServiceProfilesApi
+from scm.identity_services.api.trusted_certificate_authorities_api import TrustedCertificateAuthoritiesApi
+
diff --git a/scm/identity_services/api/authentication_portals_api.py b/scm/identity_services/api/authentication_portals_api.py
new file mode 100644
index 00000000..2972f798
--- /dev/null
+++ b/scm/identity_services/api/authentication_portals_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from scm.identity_services.models.authentication_portals_list_response import AuthenticationPortalsListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AuthenticationPortalsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_portals(
+ self,
+ authentication_portals: Annotated[Optional[AuthenticationPortals], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationPortals:
+ """Create an authentication portal
+
+ Create a new authentication portal.
+
+ :param authentication_portals: Created
+ :type authentication_portals: AuthenticationPortals
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_portals_serialize(
+ authentication_portals=authentication_portals,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_portals_with_http_info(
+ self,
+ authentication_portals: Annotated[Optional[AuthenticationPortals], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationPortals]:
+ """Create an authentication portal
+
+ Create a new authentication portal.
+
+ :param authentication_portals: Created
+ :type authentication_portals: AuthenticationPortals
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_portals_serialize(
+ authentication_portals=authentication_portals,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_portals_without_preload_content(
+ self,
+ authentication_portals: Annotated[Optional[AuthenticationPortals], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an authentication portal
+
+ Create a new authentication portal.
+
+ :param authentication_portals: Created
+ :type authentication_portals: AuthenticationPortals
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_portals_serialize(
+ authentication_portals=authentication_portals,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_authentication_portals_serialize(
+ self,
+ authentication_portals,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_portals is not None:
+ _body_params = authentication_portals
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/authentication-portals',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_portals_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an authentication portal
+
+ Delete an authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_portals_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_portals_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an authentication portal
+
+ Delete an authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_portals_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_portals_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an authentication portal
+
+ Delete an authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_portals_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_authentication_portals_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/authentication-portals/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_portals_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationPortals:
+ """Get an authentication portal
+
+ Get an existing authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_portals_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_portals_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationPortals]:
+ """Get an authentication portal
+
+ Get an existing authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_portals_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_portals_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an authentication portal
+
+ Get an existing authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_portals_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_authentication_portals_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-portals/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_portals(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationPortalsListResponse:
+ """List authentication portals
+
+ Retreive a list of authentication portals.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_portals_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortalsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_portals_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationPortalsListResponse]:
+ """List authentication portals
+
+ Retreive a list of authentication portals.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_portals_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortalsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_portals_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List authentication portals
+
+ Retreive a list of authentication portals.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_portals_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortalsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_authentication_portals_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-portals',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_portals_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_portals: Annotated[Optional[AuthenticationPortals], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationPortals:
+ """Update an authentication portal
+
+ Update an existing authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_portals: OK
+ :type authentication_portals: AuthenticationPortals
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_portals_by_id_serialize(
+ id=id,
+ authentication_portals=authentication_portals,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_portals_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_portals: Annotated[Optional[AuthenticationPortals], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationPortals]:
+ """Update an authentication portal
+
+ Update an existing authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_portals: OK
+ :type authentication_portals: AuthenticationPortals
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_portals_by_id_serialize(
+ id=id,
+ authentication_portals=authentication_portals,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_portals_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_portals: Annotated[Optional[AuthenticationPortals], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an authentication portal
+
+ Update an existing authentication portal.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_portals: OK
+ :type authentication_portals: AuthenticationPortals
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_portals_by_id_serialize(
+ id=id,
+ authentication_portals=authentication_portals,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationPortals",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_authentication_portals(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single authentication_portals object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_authentication_portals(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_authentication_portals(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_authentication_portals_by_id_serialize(
+ self,
+ id,
+ authentication_portals,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_portals is not None:
+ _body_params = authentication_portals
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/authentication-portals/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/authentication_profiles_api.py b/scm/identity_services/api/authentication_profiles_api.py
new file mode 100644
index 00000000..02e7917c
--- /dev/null
+++ b/scm/identity_services/api/authentication_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.models.authentication_profiles_list_response import AuthenticationProfilesListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AuthenticationProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_profiles(
+ self,
+ authentication_profiles: Annotated[Optional[AuthenticationProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationProfiles:
+ """Create an authentication profile
+
+ Create an authentication profile.
+
+ :param authentication_profiles: Created
+ :type authentication_profiles: AuthenticationProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_profiles_serialize(
+ authentication_profiles=authentication_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_profiles_with_http_info(
+ self,
+ authentication_profiles: Annotated[Optional[AuthenticationProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationProfiles]:
+ """Create an authentication profile
+
+ Create an authentication profile.
+
+ :param authentication_profiles: Created
+ :type authentication_profiles: AuthenticationProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_profiles_serialize(
+ authentication_profiles=authentication_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_profiles_without_preload_content(
+ self,
+ authentication_profiles: Annotated[Optional[AuthenticationProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an authentication profile
+
+ Create an authentication profile.
+
+ :param authentication_profiles: Created
+ :type authentication_profiles: AuthenticationProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_profiles_serialize(
+ authentication_profiles=authentication_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_authentication_profiles_serialize(
+ self,
+ authentication_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_profiles is not None:
+ _body_params = authentication_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/authentication-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an authentication profile
+
+ Delete an authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an authentication profile
+
+ Delete an authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an authentication profile
+
+ Delete an authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/authentication-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationProfiles:
+ """Get an authentication profile
+
+ Get an existing authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationProfiles]:
+ """Get an authentication profile
+
+ Get an existing authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an authentication profile
+
+ Get an existing authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationProfilesListResponse:
+ """List authentication profiles
+
+ Retrieve a list of authentication profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationProfilesListResponse]:
+ """List authentication profiles
+
+ Retrieve a list of authentication profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List authentication profiles
+
+ Retrieve a list of authentication profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_authentication_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_profiles: Annotated[Optional[AuthenticationProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationProfiles:
+ """Update an authentication profile
+
+ Update an existing authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_profiles: OK
+ :type authentication_profiles: AuthenticationProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_profiles_by_id_serialize(
+ id=id,
+ authentication_profiles=authentication_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_profiles: Annotated[Optional[AuthenticationProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationProfiles]:
+ """Update an authentication profile
+
+ Update an existing authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_profiles: OK
+ :type authentication_profiles: AuthenticationProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_profiles_by_id_serialize(
+ id=id,
+ authentication_profiles=authentication_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_profiles: Annotated[Optional[AuthenticationProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an authentication profile
+
+ Update an existing authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_profiles: OK
+ :type authentication_profiles: AuthenticationProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_profiles_by_id_serialize(
+ id=id,
+ authentication_profiles=authentication_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_authentication_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single authentication_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_authentication_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_authentication_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ authentication_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_profiles is not None:
+ _body_params = authentication_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/authentication-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/authentication_rules_api.py b/scm/identity_services/api/authentication_rules_api.py
new file mode 100644
index 00000000..34c1e895
--- /dev/null
+++ b/scm/identity_services/api/authentication_rules_api.py
@@ -0,0 +1,1958 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from scm.identity_services.models.authentication_rules_list_response import AuthenticationRulesListResponse
+from scm.identity_services.models.rule_based_move import RuleBasedMove
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AuthenticationRulesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_rules(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ authentication_rules: Annotated[Optional[AuthenticationRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationRules:
+ """Create an authentication rule
+
+ Create a new authentication rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param authentication_rules: Created
+ :type authentication_rules: AuthenticationRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_rules_serialize(
+ position=position,
+ authentication_rules=authentication_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_rules_with_http_info(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ authentication_rules: Annotated[Optional[AuthenticationRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationRules]:
+ """Create an authentication rule
+
+ Create a new authentication rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param authentication_rules: Created
+ :type authentication_rules: AuthenticationRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_rules_serialize(
+ position=position,
+ authentication_rules=authentication_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_rules_without_preload_content(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ authentication_rules: Annotated[Optional[AuthenticationRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an authentication rule
+
+ Create a new authentication rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param authentication_rules: Created
+ :type authentication_rules: AuthenticationRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_rules_serialize(
+ position=position,
+ authentication_rules=authentication_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_authentication_rules_serialize(
+ self,
+ position,
+ authentication_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_rules is not None:
+ _body_params = authentication_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/authentication-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an authentication rule
+
+ Delete an authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an authentication rule
+
+ Delete an authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an authentication rule
+
+ Delete an authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_authentication_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/authentication-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationRules:
+ """Get an authentication rule
+
+ Get an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationRules]:
+ """Get an authentication rule
+
+ Get an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an authentication rule
+
+ Get an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_authentication_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_rules(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationRulesListResponse:
+ """List authentication rules
+
+ Retrieve a list of authentication rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_rules_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_rules_with_http_info(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationRulesListResponse]:
+ """List authentication rules
+
+ Retrieve a list of authentication rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_rules_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_rules_without_preload_content(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List authentication rules
+
+ Retrieve a list of authentication rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_rules_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_authentication_rules_serialize(
+ self,
+ position,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def move_authentication_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ rule_based_move: Annotated[Optional[RuleBasedMove], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Move an authentication rule
+
+ Move an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param rule_based_move: OK
+ :type rule_based_move: RuleBasedMove
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._move_authentication_rules_by_id_serialize(
+ id=id,
+ rule_based_move=rule_based_move,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def move_authentication_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ rule_based_move: Annotated[Optional[RuleBasedMove], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Move an authentication rule
+
+ Move an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param rule_based_move: OK
+ :type rule_based_move: RuleBasedMove
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._move_authentication_rules_by_id_serialize(
+ id=id,
+ rule_based_move=rule_based_move,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def move_authentication_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ rule_based_move: Annotated[Optional[RuleBasedMove], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Move an authentication rule
+
+ Move an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param rule_based_move: OK
+ :type rule_based_move: RuleBasedMove
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._move_authentication_rules_by_id_serialize(
+ id=id,
+ rule_based_move=rule_based_move,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _move_authentication_rules_by_id_serialize(
+ self,
+ id,
+ rule_based_move,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if rule_based_move is not None:
+ _body_params = rule_based_move
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/authentication-rules/{id}:move',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_rules: Annotated[Optional[AuthenticationRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationRules:
+ """Update an authentication rule
+
+ Update an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_rules: OK
+ :type authentication_rules: AuthenticationRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_rules_by_id_serialize(
+ id=id,
+ authentication_rules=authentication_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_rules: Annotated[Optional[AuthenticationRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationRules]:
+ """Update an authentication rule
+
+ Update an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_rules: OK
+ :type authentication_rules: AuthenticationRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_rules_by_id_serialize(
+ id=id,
+ authentication_rules=authentication_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_rules: Annotated[Optional[AuthenticationRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an authentication rule
+
+ Update an existing authentication rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_rules: OK
+ :type authentication_rules: AuthenticationRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_rules_by_id_serialize(
+ id=id,
+ authentication_rules=authentication_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_authentication_rules(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single authentication_rules object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_authentication_rules(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_authentication_rules(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_authentication_rules_by_id_serialize(
+ self,
+ id,
+ authentication_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_rules is not None:
+ _body_params = authentication_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/authentication-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/authentication_sequences_api.py b/scm/identity_services/api/authentication_sequences_api.py
new file mode 100644
index 00000000..f80d8e06
--- /dev/null
+++ b/scm/identity_services/api/authentication_sequences_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from scm.identity_services.models.authentication_sequences_list_response import AuthenticationSequencesListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AuthenticationSequencesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_sequences(
+ self,
+ authentication_sequences: Annotated[Optional[AuthenticationSequences], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationSequences:
+ """Create an authentication sequence
+
+ Create a new authentication sequence.
+
+ :param authentication_sequences: Created
+ :type authentication_sequences: AuthenticationSequences
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_sequences_serialize(
+ authentication_sequences=authentication_sequences,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_sequences_with_http_info(
+ self,
+ authentication_sequences: Annotated[Optional[AuthenticationSequences], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationSequences]:
+ """Create an authentication sequence
+
+ Create a new authentication sequence.
+
+ :param authentication_sequences: Created
+ :type authentication_sequences: AuthenticationSequences
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_sequences_serialize(
+ authentication_sequences=authentication_sequences,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_authentication_sequences_without_preload_content(
+ self,
+ authentication_sequences: Annotated[Optional[AuthenticationSequences], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an authentication sequence
+
+ Create a new authentication sequence.
+
+ :param authentication_sequences: Created
+ :type authentication_sequences: AuthenticationSequences
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_authentication_sequences_serialize(
+ authentication_sequences=authentication_sequences,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_authentication_sequences_serialize(
+ self,
+ authentication_sequences,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_sequences is not None:
+ _body_params = authentication_sequences
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/authentication-sequences',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_sequences_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an authentication sequence
+
+ Delete an authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_sequences_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_sequences_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an authentication sequence
+
+ Delete an authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_sequences_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_authentication_sequences_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an authentication sequence
+
+ Delete an authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_authentication_sequences_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_authentication_sequences_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/authentication-sequences/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_sequences_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationSequences:
+ """Get an authentication sequence
+
+ Get an existing authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_sequences_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_sequences_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationSequences]:
+ """Get an authentication sequence
+
+ Get an existing authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_sequences_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_authentication_sequences_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an authentication sequence
+
+ Get an existing authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_authentication_sequences_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_authentication_sequences_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-sequences/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_sequences(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationSequencesListResponse:
+ """List authentication sequences
+
+ Retrieve a list of authentication sequences.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_sequences_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequencesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_sequences_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationSequencesListResponse]:
+ """List authentication sequences
+
+ Retrieve a list of authentication sequences.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_sequences_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequencesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_authentication_sequences_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List authentication sequences
+
+ Retrieve a list of authentication sequences.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_authentication_sequences_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequencesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_authentication_sequences_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/authentication-sequences',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_sequences_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_sequences: Annotated[Optional[AuthenticationSequences], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AuthenticationSequences:
+ """Update an authentication sequence
+
+ Update an existing authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_sequences: OK
+ :type authentication_sequences: AuthenticationSequences
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_sequences_by_id_serialize(
+ id=id,
+ authentication_sequences=authentication_sequences,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_sequences_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_sequences: Annotated[Optional[AuthenticationSequences], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AuthenticationSequences]:
+ """Update an authentication sequence
+
+ Update an existing authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_sequences: OK
+ :type authentication_sequences: AuthenticationSequences
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_sequences_by_id_serialize(
+ id=id,
+ authentication_sequences=authentication_sequences,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_authentication_sequences_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ authentication_sequences: Annotated[Optional[AuthenticationSequences], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an authentication sequence
+
+ Update an existing authentication sequence.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param authentication_sequences: OK
+ :type authentication_sequences: AuthenticationSequences
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_authentication_sequences_by_id_serialize(
+ id=id,
+ authentication_sequences=authentication_sequences,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AuthenticationSequences",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_authentication_sequences(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single authentication_sequences object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_authentication_sequences(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_authentication_sequences(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_authentication_sequences_by_id_serialize(
+ self,
+ id,
+ authentication_sequences,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if authentication_sequences is not None:
+ _body_params = authentication_sequences
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/authentication-sequences/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/certificate_profiles_api.py b/scm/identity_services/api/certificate_profiles_api.py
new file mode 100644
index 00000000..4262255c
--- /dev/null
+++ b/scm/identity_services/api/certificate_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from scm.identity_services.models.certificate_profiles_list_response import CertificateProfilesListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class CertificateProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_certificate_profiles(
+ self,
+ certificate_profiles: Annotated[Optional[CertificateProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> CertificateProfiles:
+ """Create a certificate profile
+
+ Create a certificate profile.
+
+ :param certificate_profiles: Created
+ :type certificate_profiles: CertificateProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_certificate_profiles_serialize(
+ certificate_profiles=certificate_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_certificate_profiles_with_http_info(
+ self,
+ certificate_profiles: Annotated[Optional[CertificateProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[CertificateProfiles]:
+ """Create a certificate profile
+
+ Create a certificate profile.
+
+ :param certificate_profiles: Created
+ :type certificate_profiles: CertificateProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_certificate_profiles_serialize(
+ certificate_profiles=certificate_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_certificate_profiles_without_preload_content(
+ self,
+ certificate_profiles: Annotated[Optional[CertificateProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a certificate profile
+
+ Create a certificate profile.
+
+ :param certificate_profiles: Created
+ :type certificate_profiles: CertificateProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_certificate_profiles_serialize(
+ certificate_profiles=certificate_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_certificate_profiles_serialize(
+ self,
+ certificate_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if certificate_profiles is not None:
+ _body_params = certificate_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/certificate-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_certificate_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a certificate profile
+
+ Delete a certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_certificate_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_certificate_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a certificate profile
+
+ Delete a certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_certificate_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_certificate_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a certificate profile
+
+ Delete a certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_certificate_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_certificate_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/certificate-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_certificate_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> CertificateProfiles:
+ """Get a certificate profile
+
+ Get an existing certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_certificate_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_certificate_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[CertificateProfiles]:
+ """Get a certificate profile
+
+ Get an existing certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_certificate_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_certificate_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a certificate profile
+
+ Get an existing certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_certificate_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_certificate_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/certificate-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_certificate_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> CertificateProfilesListResponse:
+ """List certificate profiles
+
+ Retrieve a list of certificate profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_certificate_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_certificate_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[CertificateProfilesListResponse]:
+ """List certificate profiles
+
+ Retrieve a list of certificate profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_certificate_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_certificate_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List certificate profiles
+
+ Retrieve a list of certificate profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_certificate_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_certificate_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/certificate-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_certificate_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ certificate_profiles: Annotated[Optional[CertificateProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> CertificateProfiles:
+ """Update a certificate profile
+
+ Update an existing certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param certificate_profiles: OK
+ :type certificate_profiles: CertificateProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_certificate_profiles_by_id_serialize(
+ id=id,
+ certificate_profiles=certificate_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_certificate_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ certificate_profiles: Annotated[Optional[CertificateProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[CertificateProfiles]:
+ """Update a certificate profile
+
+ Update an existing certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param certificate_profiles: OK
+ :type certificate_profiles: CertificateProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_certificate_profiles_by_id_serialize(
+ id=id,
+ certificate_profiles=certificate_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_certificate_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ certificate_profiles: Annotated[Optional[CertificateProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a certificate profile
+
+ Update an existing certificate profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param certificate_profiles: OK
+ :type certificate_profiles: CertificateProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_certificate_profiles_by_id_serialize(
+ id=id,
+ certificate_profiles=certificate_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificateProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_certificate_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single certificate_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_certificate_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_certificate_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_certificate_profiles_by_id_serialize(
+ self,
+ id,
+ certificate_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if certificate_profiles is not None:
+ _body_params = certificate_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/certificate-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/certificates_api.py b/scm/identity_services/api/certificates_api.py
new file mode 100644
index 00000000..8fe7ad18
--- /dev/null
+++ b/scm/identity_services/api/certificates_api.py
@@ -0,0 +1,1622 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.certificates_get import CertificatesGet
+from scm.identity_services.models.certificates_list_response import CertificatesListResponse
+from scm.identity_services.models.certificates_post import CertificatesPost
+from scm.identity_services.models.export_certificate_payload import ExportCertificatePayload
+from scm.identity_services.models.export_certificate_response import ExportCertificateResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class CertificatesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_certificates(
+ self,
+ certificates_post: Annotated[Optional[CertificatesPost], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> CertificatesGet:
+ """Generate a certificate
+
+ Generate a new certificate.
+
+ :param certificates_post: Created
+ :type certificates_post: CertificatesPost
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_certificates_serialize(
+ certificates_post=certificates_post,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "CertificatesGet",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_certificates_with_http_info(
+ self,
+ certificates_post: Annotated[Optional[CertificatesPost], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[CertificatesGet]:
+ """Generate a certificate
+
+ Generate a new certificate.
+
+ :param certificates_post: Created
+ :type certificates_post: CertificatesPost
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_certificates_serialize(
+ certificates_post=certificates_post,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "CertificatesGet",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_certificates_without_preload_content(
+ self,
+ certificates_post: Annotated[Optional[CertificatesPost], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Generate a certificate
+
+ Generate a new certificate.
+
+ :param certificates_post: Created
+ :type certificates_post: CertificatesPost
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_certificates_serialize(
+ certificates_post=certificates_post,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "CertificatesGet",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_certificates_serialize(
+ self,
+ certificates_post,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if certificates_post is not None:
+ _body_params = certificates_post
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/certificates',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_certificates_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a certificate
+
+ Delete a certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_certificates_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_certificates_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a certificate
+
+ Delete a certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_certificates_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_certificates_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a certificate
+
+ Delete a certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_certificates_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_certificates_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/certificates/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def export_certificate_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ export_certificate_payload: Annotated[Optional[ExportCertificatePayload], Field(description="Export a Certificate")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ExportCertificateResponse:
+ """Export a certificate
+
+ Export a certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param export_certificate_payload: Export a Certificate
+ :type export_certificate_payload: ExportCertificatePayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._export_certificate_by_id_serialize(
+ id=id,
+ export_certificate_payload=export_certificate_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ExportCertificateResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def export_certificate_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ export_certificate_payload: Annotated[Optional[ExportCertificatePayload], Field(description="Export a Certificate")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ExportCertificateResponse]:
+ """Export a certificate
+
+ Export a certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param export_certificate_payload: Export a Certificate
+ :type export_certificate_payload: ExportCertificatePayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._export_certificate_by_id_serialize(
+ id=id,
+ export_certificate_payload=export_certificate_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ExportCertificateResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def export_certificate_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ export_certificate_payload: Annotated[Optional[ExportCertificatePayload], Field(description="Export a Certificate")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Export a certificate
+
+ Export a certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param export_certificate_payload: Export a Certificate
+ :type export_certificate_payload: ExportCertificatePayload
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._export_certificate_by_id_serialize(
+ id=id,
+ export_certificate_payload=export_certificate_payload,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ExportCertificateResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _export_certificate_by_id_serialize(
+ self,
+ id,
+ export_certificate_payload,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if export_certificate_payload is not None:
+ _body_params = export_certificate_payload
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/certificates/{id}:export',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_certificates_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> CertificatesGet:
+ """Get a certificate
+
+ Get an existing certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_certificates_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificatesGet",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_certificates_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[CertificatesGet]:
+ """Get a certificate
+
+ Get an existing certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_certificates_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificatesGet",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_certificates_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a certificate
+
+ Get an existing certificate.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_certificates_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificatesGet",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_certificates_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/certificates/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_certificates(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> CertificatesListResponse:
+ """List certificates
+
+ Retrieve a list of certificates.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_certificates_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificatesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_certificates_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[CertificatesListResponse]:
+ """List certificates
+
+ Retrieve a list of certificates.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_certificates_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificatesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_certificates_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List certificates
+
+ Retrieve a list of certificates.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_certificates_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "CertificatesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_certificates(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single certificates object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_certificates(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_certificates(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _list_certificates_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/certificates',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/kerberos_server_profiles_api.py b/scm/identity_services/api/kerberos_server_profiles_api.py
new file mode 100644
index 00000000..9fa1912c
--- /dev/null
+++ b/scm/identity_services/api/kerberos_server_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from scm.identity_services.models.kerberos_server_profiles_list_response import KerberosServerProfilesListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class KerberosServerProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_kerberos_server_profiles(
+ self,
+ kerberos_server_profiles: Annotated[Optional[KerberosServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> KerberosServerProfiles:
+ """Create a Kerberos server profile
+
+ Create a new Kerberos server profile.
+
+ :param kerberos_server_profiles: Created
+ :type kerberos_server_profiles: KerberosServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_kerberos_server_profiles_serialize(
+ kerberos_server_profiles=kerberos_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_kerberos_server_profiles_with_http_info(
+ self,
+ kerberos_server_profiles: Annotated[Optional[KerberosServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[KerberosServerProfiles]:
+ """Create a Kerberos server profile
+
+ Create a new Kerberos server profile.
+
+ :param kerberos_server_profiles: Created
+ :type kerberos_server_profiles: KerberosServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_kerberos_server_profiles_serialize(
+ kerberos_server_profiles=kerberos_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_kerberos_server_profiles_without_preload_content(
+ self,
+ kerberos_server_profiles: Annotated[Optional[KerberosServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a Kerberos server profile
+
+ Create a new Kerberos server profile.
+
+ :param kerberos_server_profiles: Created
+ :type kerberos_server_profiles: KerberosServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_kerberos_server_profiles_serialize(
+ kerberos_server_profiles=kerberos_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_kerberos_server_profiles_serialize(
+ self,
+ kerberos_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if kerberos_server_profiles is not None:
+ _body_params = kerberos_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/kerberos-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_kerberos_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a Kerberos server profile
+
+ Delete a Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_kerberos_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a Kerberos server profile
+
+ Delete a Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_kerberos_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a Kerberos server profile
+
+ Delete a Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_kerberos_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/kerberos-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_kerberos_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> KerberosServerProfiles:
+ """Get a Kerberos server profile
+
+ Get an existing Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_kerberos_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[KerberosServerProfiles]:
+ """Get a Kerberos server profile
+
+ Get an existing Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_kerberos_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a Kerberos server profile
+
+ Get an existing Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_kerberos_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/kerberos-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_kerberos_server_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> KerberosServerProfilesListResponse:
+ """List Kerberos server profiles
+
+ Retrieve a list of Kerberos server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_kerberos_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_kerberos_server_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[KerberosServerProfilesListResponse]:
+ """List Kerberos server profiles
+
+ Retrieve a list of Kerberos server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_kerberos_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_kerberos_server_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List Kerberos server profiles
+
+ Retrieve a list of Kerberos server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_kerberos_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_kerberos_server_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/kerberos-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_kerberos_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ kerberos_server_profiles: Annotated[Optional[KerberosServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> KerberosServerProfiles:
+ """Update a Kerberos server profile
+
+ Update an existing Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param kerberos_server_profiles: OK
+ :type kerberos_server_profiles: KerberosServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ kerberos_server_profiles=kerberos_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_kerberos_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ kerberos_server_profiles: Annotated[Optional[KerberosServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[KerberosServerProfiles]:
+ """Update a Kerberos server profile
+
+ Update an existing Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param kerberos_server_profiles: OK
+ :type kerberos_server_profiles: KerberosServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ kerberos_server_profiles=kerberos_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_kerberos_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ kerberos_server_profiles: Annotated[Optional[KerberosServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a Kerberos server profile
+
+ Update an existing Kerberos server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param kerberos_server_profiles: OK
+ :type kerberos_server_profiles: KerberosServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_kerberos_server_profiles_by_id_serialize(
+ id=id,
+ kerberos_server_profiles=kerberos_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "KerberosServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_kerberos_server_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single kerberos_server_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_kerberos_server_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_kerberos_server_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_kerberos_server_profiles_by_id_serialize(
+ self,
+ id,
+ kerberos_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if kerberos_server_profiles is not None:
+ _body_params = kerberos_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/kerberos-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/ldap_server_profiles_api.py b/scm/identity_services/api/ldap_server_profiles_api.py
new file mode 100644
index 00000000..a6df469e
--- /dev/null
+++ b/scm/identity_services/api/ldap_server_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.ldap_server_profiles_list_response import LDAPServerProfilesListResponse
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LDAPServerProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_ldap_server_profiles(
+ self,
+ ldap_server_profiles: Annotated[Optional[LdapServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LdapServerProfiles:
+ """Create an LDAP server profile
+
+ Create a new LDAP server profile.
+
+ :param ldap_server_profiles: Created
+ :type ldap_server_profiles: LdapServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ldap_server_profiles_serialize(
+ ldap_server_profiles=ldap_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_ldap_server_profiles_with_http_info(
+ self,
+ ldap_server_profiles: Annotated[Optional[LdapServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LdapServerProfiles]:
+ """Create an LDAP server profile
+
+ Create a new LDAP server profile.
+
+ :param ldap_server_profiles: Created
+ :type ldap_server_profiles: LdapServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ldap_server_profiles_serialize(
+ ldap_server_profiles=ldap_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_ldap_server_profiles_without_preload_content(
+ self,
+ ldap_server_profiles: Annotated[Optional[LdapServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an LDAP server profile
+
+ Create a new LDAP server profile.
+
+ :param ldap_server_profiles: Created
+ :type ldap_server_profiles: LdapServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ldap_server_profiles_serialize(
+ ldap_server_profiles=ldap_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_ldap_server_profiles_serialize(
+ self,
+ ldap_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ldap_server_profiles is not None:
+ _body_params = ldap_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ldap-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ldap_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an LDAP server profile
+
+ Delete a LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ldap_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ldap_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an LDAP server profile
+
+ Delete a LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ldap_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ldap_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an LDAP server profile
+
+ Delete a LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ldap_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_ldap_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ldap-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_ldap_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LdapServerProfiles:
+ """Get an LDAP server profile
+
+ Get an existing LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ldap_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_ldap_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LdapServerProfiles]:
+ """Get an LDAP server profile
+
+ Get an existing LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ldap_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_ldap_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an LDAP server profile
+
+ Get an existing LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ldap_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_ldap_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ldap-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_ldap_server_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LDAPServerProfilesListResponse:
+ """List LDAP server profiles
+
+ Retrieve a list of LDAP server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ldap_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LDAPServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_ldap_server_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LDAPServerProfilesListResponse]:
+ """List LDAP server profiles
+
+ Retrieve a list of LDAP server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ldap_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LDAPServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_ldap_server_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List LDAP server profiles
+
+ Retrieve a list of LDAP server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ldap_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LDAPServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_ldap_server_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ldap-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_ldap_server_profiles(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ldap_server_profiles: Annotated[Optional[LdapServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LdapServerProfiles:
+ """Update an LDAP server profile
+
+ Update an existing LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ldap_server_profiles: OK
+ :type ldap_server_profiles: LdapServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ldap_server_profiles_serialize(
+ id=id,
+ ldap_server_profiles=ldap_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_ldap_server_profiles_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ldap_server_profiles: Annotated[Optional[LdapServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LdapServerProfiles]:
+ """Update an LDAP server profile
+
+ Update an existing LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ldap_server_profiles: OK
+ :type ldap_server_profiles: LdapServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ldap_server_profiles_serialize(
+ id=id,
+ ldap_server_profiles=ldap_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_ldap_server_profiles_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ldap_server_profiles: Annotated[Optional[LdapServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an LDAP server profile
+
+ Update an existing LDAP server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ldap_server_profiles: OK
+ :type ldap_server_profiles: LdapServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ldap_server_profiles_serialize(
+ id=id,
+ ldap_server_profiles=ldap_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LdapServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ldap_server_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ldap_server_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ldap_server_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_ldap_server_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_ldap_server_profiles_serialize(
+ self,
+ id,
+ ldap_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ldap_server_profiles is not None:
+ _body_params = ldap_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ldap-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/local_user_groups_api.py b/scm/identity_services/api/local_user_groups_api.py
new file mode 100644
index 00000000..b98f11cb
--- /dev/null
+++ b/scm/identity_services/api/local_user_groups_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from scm.identity_services.models.local_user_groups_list_response import LocalUserGroupsListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LocalUserGroupsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_local_user_groups(
+ self,
+ local_user_groups: Annotated[Optional[LocalUserGroups], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUserGroups:
+ """Create a local user group
+
+ Create a new local user group.
+
+ :param local_user_groups: Created
+ :type local_user_groups: LocalUserGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_local_user_groups_serialize(
+ local_user_groups=local_user_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_local_user_groups_with_http_info(
+ self,
+ local_user_groups: Annotated[Optional[LocalUserGroups], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUserGroups]:
+ """Create a local user group
+
+ Create a new local user group.
+
+ :param local_user_groups: Created
+ :type local_user_groups: LocalUserGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_local_user_groups_serialize(
+ local_user_groups=local_user_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_local_user_groups_without_preload_content(
+ self,
+ local_user_groups: Annotated[Optional[LocalUserGroups], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a local user group
+
+ Create a new local user group.
+
+ :param local_user_groups: Created
+ :type local_user_groups: LocalUserGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_local_user_groups_serialize(
+ local_user_groups=local_user_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_local_user_groups_serialize(
+ self,
+ local_user_groups,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if local_user_groups is not None:
+ _body_params = local_user_groups
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/local-user-groups',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_local_user_groups_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a local user group
+
+ Delete a local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_local_user_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_local_user_groups_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a local user group
+
+ Delete a local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_local_user_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_local_user_groups_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a local user group
+
+ Delete a local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_local_user_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_local_user_groups_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/local-user-groups/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_local_user_groups_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUserGroups:
+ """Get a local user group
+
+ Get an existing local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_local_user_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_local_user_groups_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUserGroups]:
+ """Get a local user group
+
+ Get an existing local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_local_user_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_local_user_groups_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a local user group
+
+ Get an existing local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_local_user_groups_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_local_user_groups_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/local-user-groups/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_local_user_groups(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUserGroupsListResponse:
+ """List local user groups
+
+ Retrieve a list of local user groups.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_local_user_groups_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroupsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_local_user_groups_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUserGroupsListResponse]:
+ """List local user groups
+
+ Retrieve a list of local user groups.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_local_user_groups_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroupsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_local_user_groups_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List local user groups
+
+ Retrieve a list of local user groups.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_local_user_groups_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroupsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_local_user_groups_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/local-user-groups',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_local_user_groups_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ local_user_groups: Annotated[Optional[LocalUserGroups], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUserGroups:
+ """Update a local user group
+
+ Update an existing local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param local_user_groups: OK
+ :type local_user_groups: LocalUserGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_local_user_groups_by_id_serialize(
+ id=id,
+ local_user_groups=local_user_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_local_user_groups_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ local_user_groups: Annotated[Optional[LocalUserGroups], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUserGroups]:
+ """Update a local user group
+
+ Update an existing local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param local_user_groups: OK
+ :type local_user_groups: LocalUserGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_local_user_groups_by_id_serialize(
+ id=id,
+ local_user_groups=local_user_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_local_user_groups_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ local_user_groups: Annotated[Optional[LocalUserGroups], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a local user group
+
+ Update an existing local user group.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param local_user_groups: OK
+ :type local_user_groups: LocalUserGroups
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_local_user_groups_by_id_serialize(
+ id=id,
+ local_user_groups=local_user_groups,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUserGroups",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_local_user_groups(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single local_user_groups object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_local_user_groups(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_local_user_groups(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_local_user_groups_by_id_serialize(
+ self,
+ id,
+ local_user_groups,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if local_user_groups is not None:
+ _body_params = local_user_groups
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/local-user-groups/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/local_users_api.py b/scm/identity_services/api/local_users_api.py
new file mode 100644
index 00000000..55cc2141
--- /dev/null
+++ b/scm/identity_services/api/local_users_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.local_users import LocalUsers
+from scm.identity_services.models.local_users_list_response import LocalUsersListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LocalUsersApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_local_users(
+ self,
+ local_users: Annotated[Optional[LocalUsers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUsers:
+ """Create a local user
+
+ Create a new local user.
+
+ :param local_users: Created
+ :type local_users: LocalUsers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_local_users_serialize(
+ local_users=local_users,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_local_users_with_http_info(
+ self,
+ local_users: Annotated[Optional[LocalUsers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUsers]:
+ """Create a local user
+
+ Create a new local user.
+
+ :param local_users: Created
+ :type local_users: LocalUsers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_local_users_serialize(
+ local_users=local_users,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_local_users_without_preload_content(
+ self,
+ local_users: Annotated[Optional[LocalUsers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a local user
+
+ Create a new local user.
+
+ :param local_users: Created
+ :type local_users: LocalUsers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_local_users_serialize(
+ local_users=local_users,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_local_users_serialize(
+ self,
+ local_users,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if local_users is not None:
+ _body_params = local_users
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/local-users',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_local_users_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a local user
+
+ Delete a local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_local_users_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_local_users_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a local user
+
+ Delete a local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_local_users_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_local_users_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a local user
+
+ Delete a local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_local_users_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_local_users_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/local-users/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_local_users_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUsers:
+ """Get a local user
+
+ Get an existing local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_local_users_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_local_users_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUsers]:
+ """Get a local user
+
+ Get an existing local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_local_users_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_local_users_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a local user
+
+ Get an existing local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_local_users_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_local_users_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/local-users/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_local_users(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUsersListResponse:
+ """List local users
+
+ Retrieve a list of local users.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_local_users_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_local_users_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUsersListResponse]:
+ """List local users
+
+ Retrieve a list of local users.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_local_users_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_local_users_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List local users
+
+ Retrieve a list of local users.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_local_users_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_local_users_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/local-users',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_local_users_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ local_users: Annotated[Optional[LocalUsers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LocalUsers:
+ """Update a local user
+
+ Update an existing local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param local_users: OK
+ :type local_users: LocalUsers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_local_users_by_id_serialize(
+ id=id,
+ local_users=local_users,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_local_users_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ local_users: Annotated[Optional[LocalUsers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LocalUsers]:
+ """Update a local user
+
+ Update an existing local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param local_users: OK
+ :type local_users: LocalUsers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_local_users_by_id_serialize(
+ id=id,
+ local_users=local_users,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_local_users_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ local_users: Annotated[Optional[LocalUsers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a local user
+
+ Update an existing local user.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param local_users: OK
+ :type local_users: LocalUsers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_local_users_by_id_serialize(
+ id=id,
+ local_users=local_users,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LocalUsers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_local_users(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single local_users object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_local_users(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_local_users(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_local_users_by_id_serialize(
+ self,
+ id,
+ local_users,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if local_users is not None:
+ _body_params = local_users
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/local-users/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/mfa_servers_api.py b/scm/identity_services/api/mfa_servers_api.py
new file mode 100644
index 00000000..0bc2c25a
--- /dev/null
+++ b/scm/identity_services/api/mfa_servers_api.py
@@ -0,0 +1,1636 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.mfa_servers_list_response import MFAServersListResponse
+from scm.identity_services.models.mfa_servers import MfaServers
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class MFAServersApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_mfa_servers(
+ self,
+ mfa_servers: Annotated[Optional[MfaServers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> MfaServers:
+ """Create an MFA server
+
+ Create a new MFA server.
+
+ :param mfa_servers: Created
+ :type mfa_servers: MfaServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_mfa_servers_serialize(
+ mfa_servers=mfa_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_mfa_servers_with_http_info(
+ self,
+ mfa_servers: Annotated[Optional[MfaServers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[MfaServers]:
+ """Create an MFA server
+
+ Create a new MFA server.
+
+ :param mfa_servers: Created
+ :type mfa_servers: MfaServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_mfa_servers_serialize(
+ mfa_servers=mfa_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_mfa_servers_without_preload_content(
+ self,
+ mfa_servers: Annotated[Optional[MfaServers], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an MFA server
+
+ Create a new MFA server.
+
+ :param mfa_servers: Created
+ :type mfa_servers: MfaServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_mfa_servers_serialize(
+ mfa_servers=mfa_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_mfa_servers_serialize(
+ self,
+ mfa_servers,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if mfa_servers is not None:
+ _body_params = mfa_servers
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/mfa-servers',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_mfa_servers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an MFA server
+
+ Delete an MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_mfa_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_mfa_servers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an MFA server
+
+ Delete an MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_mfa_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_mfa_servers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an MFA server
+
+ Delete an MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_mfa_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_mfa_servers_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/mfa-servers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_mfa_servers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> MfaServers:
+ """Get an MFA server
+
+ Get an existing MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_mfa_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_mfa_servers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[MfaServers]:
+ """Get an MFA server
+
+ Get an existing MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_mfa_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_mfa_servers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an MFA server
+
+ Get an existing MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_mfa_servers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_mfa_servers_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/mfa-servers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_mfa_servers(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> MFAServersListResponse:
+ """List MFA servers
+
+ Retrieve a list of MFA servers.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_mfa_servers_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MFAServersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_mfa_servers_with_http_info(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[MFAServersListResponse]:
+ """List MFA servers
+
+ Retrieve a list of MFA servers.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_mfa_servers_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MFAServersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_mfa_servers_without_preload_content(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule ")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List MFA servers
+
+ Retrieve a list of MFA servers.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_mfa_servers_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MFAServersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_mfa_servers_serialize(
+ self,
+ position,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/mfa-servers',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_mfa_servers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ mfa_servers: Annotated[Optional[MfaServers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> MfaServers:
+ """Update an MFA server
+
+ Update an existing MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param mfa_servers: OK
+ :type mfa_servers: MfaServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_mfa_servers_by_id_serialize(
+ id=id,
+ mfa_servers=mfa_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_mfa_servers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ mfa_servers: Annotated[Optional[MfaServers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[MfaServers]:
+ """Update an MFA server
+
+ Update an existing MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param mfa_servers: OK
+ :type mfa_servers: MfaServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_mfa_servers_by_id_serialize(
+ id=id,
+ mfa_servers=mfa_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_mfa_servers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ mfa_servers: Annotated[Optional[MfaServers], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an MFA server
+
+ Update an existing MFA server.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param mfa_servers: OK
+ :type mfa_servers: MfaServers
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_mfa_servers_by_id_serialize(
+ id=id,
+ mfa_servers=mfa_servers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "MfaServers",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_mfa_servers(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single mfa_servers object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_mfa_servers(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_mfa_servers(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_mfa_servers_by_id_serialize(
+ self,
+ id,
+ mfa_servers,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if mfa_servers is not None:
+ _body_params = mfa_servers
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/mfa-servers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/ocsp_responders_api.py b/scm/identity_services/api/ocsp_responders_api.py
new file mode 100644
index 00000000..369a7940
--- /dev/null
+++ b/scm/identity_services/api/ocsp_responders_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.ocsp_responders_list_response import OCSPRespondersListResponse
+from scm.identity_services.models.ocsp_responders import OcspResponders
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class OCSPRespondersApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_ocsp_responders(
+ self,
+ ocsp_responders: Annotated[Optional[OcspResponders], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Create an OCSP responder
+
+ Create a new OCSP responder.
+
+ :param ocsp_responders: Created
+ :type ocsp_responders: OcspResponders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ocsp_responders_serialize(
+ ocsp_responders=ocsp_responders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_ocsp_responders_with_http_info(
+ self,
+ ocsp_responders: Annotated[Optional[OcspResponders], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Create an OCSP responder
+
+ Create a new OCSP responder.
+
+ :param ocsp_responders: Created
+ :type ocsp_responders: OcspResponders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ocsp_responders_serialize(
+ ocsp_responders=ocsp_responders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_ocsp_responders_without_preload_content(
+ self,
+ ocsp_responders: Annotated[Optional[OcspResponders], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an OCSP responder
+
+ Create a new OCSP responder.
+
+ :param ocsp_responders: Created
+ :type ocsp_responders: OcspResponders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ocsp_responders_serialize(
+ ocsp_responders=ocsp_responders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_ocsp_responders_serialize(
+ self,
+ ocsp_responders,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ocsp_responders is not None:
+ _body_params = ocsp_responders
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ocsp-responders',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ocsp_responders_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an OCSP responder
+
+ Delete an OCSP responder.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ocsp_responders_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ocsp_responders_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an OCSP responder
+
+ Delete an OCSP responder.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ocsp_responders_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ocsp_responders_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an OCSP responder
+
+ Delete an OCSP responder.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ocsp_responders_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_ocsp_responders_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ocsp-responders/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_ocsp_responders_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> OcspResponders:
+ """Get an OCSP responder
+
+ Get an existing OCSP responder
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ocsp_responders_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OcspResponders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_ocsp_responders_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[OcspResponders]:
+ """Get an OCSP responder
+
+ Get an existing OCSP responder
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ocsp_responders_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OcspResponders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_ocsp_responders_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an OCSP responder
+
+ Get an existing OCSP responder
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ocsp_responders_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OcspResponders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_ocsp_responders_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ocsp-responders/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_ocsp_responders(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> OCSPRespondersListResponse:
+ """List OCSP responders
+
+ Retrieve a list of OCSP responders.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ocsp_responders_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OCSPRespondersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_ocsp_responders_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[OCSPRespondersListResponse]:
+ """List OCSP responders
+
+ Retrieve a list of OCSP responders.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ocsp_responders_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OCSPRespondersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_ocsp_responders_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List OCSP responders
+
+ Retrieve a list of OCSP responders.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ocsp_responders_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OCSPRespondersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_ocsp_responders_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ocsp-responders',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_ocsp_responders_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ocsp_responders: Annotated[Optional[OcspResponders], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> OcspResponders:
+ """Update an OCSP responder
+
+ Update an existing OCSP responder.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ocsp_responders: OK
+ :type ocsp_responders: OcspResponders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ocsp_responders_by_id_serialize(
+ id=id,
+ ocsp_responders=ocsp_responders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OcspResponders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_ocsp_responders_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ocsp_responders: Annotated[Optional[OcspResponders], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[OcspResponders]:
+ """Update an OCSP responder
+
+ Update an existing OCSP responder.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ocsp_responders: OK
+ :type ocsp_responders: OcspResponders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ocsp_responders_by_id_serialize(
+ id=id,
+ ocsp_responders=ocsp_responders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OcspResponders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_ocsp_responders_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ocsp_responders: Annotated[Optional[OcspResponders], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an OCSP responder
+
+ Update an existing OCSP responder.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ocsp_responders: OK
+ :type ocsp_responders: OcspResponders
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ocsp_responders_by_id_serialize(
+ id=id,
+ ocsp_responders=ocsp_responders,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OcspResponders",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ocsp_responders(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ocsp_responders object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ocsp_responders(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_ocsp_responders(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_ocsp_responders_by_id_serialize(
+ self,
+ id,
+ ocsp_responders,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ocsp_responders is not None:
+ _body_params = ocsp_responders
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ocsp-responders/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/radius_server_profiles_api.py b/scm/identity_services/api/radius_server_profiles_api.py
new file mode 100644
index 00000000..594a8505
--- /dev/null
+++ b/scm/identity_services/api/radius_server_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.radius_server_profiles_list_response import RADIUSServerProfilesListResponse
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class RADIUSServerProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_radius_server_profiles(
+ self,
+ radius_server_profiles: Annotated[Optional[RadiusServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RadiusServerProfiles:
+ """Create a RADIUS server profile
+
+ Create a new RADIUS server profile.
+
+ :param radius_server_profiles: Created
+ :type radius_server_profiles: RadiusServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_radius_server_profiles_serialize(
+ radius_server_profiles=radius_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_radius_server_profiles_with_http_info(
+ self,
+ radius_server_profiles: Annotated[Optional[RadiusServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RadiusServerProfiles]:
+ """Create a RADIUS server profile
+
+ Create a new RADIUS server profile.
+
+ :param radius_server_profiles: Created
+ :type radius_server_profiles: RadiusServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_radius_server_profiles_serialize(
+ radius_server_profiles=radius_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_radius_server_profiles_without_preload_content(
+ self,
+ radius_server_profiles: Annotated[Optional[RadiusServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a RADIUS server profile
+
+ Create a new RADIUS server profile.
+
+ :param radius_server_profiles: Created
+ :type radius_server_profiles: RadiusServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_radius_server_profiles_serialize(
+ radius_server_profiles=radius_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_radius_server_profiles_serialize(
+ self,
+ radius_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if radius_server_profiles is not None:
+ _body_params = radius_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/radius-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_radius_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a RADIUS server profile
+
+ Delete a RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_radius_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_radius_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a RADIUS server profile
+
+ Delete a RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_radius_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_radius_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a RADIUS server profile
+
+ Delete a RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_radius_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_radius_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/radius-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_radius_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RadiusServerProfiles:
+ """Get a RADIUS server profile
+
+ Get an existing RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_radius_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_radius_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RadiusServerProfiles]:
+ """Get a RADIUS server profile
+
+ Get an existing RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_radius_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_radius_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a RADIUS server profile
+
+ Get an existing RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_radius_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_radius_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/radius-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_radius_server_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RADIUSServerProfilesListResponse:
+ """List RADIUS server profiles
+
+ Retreive a list of RADIUS server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_radius_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RADIUSServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_radius_server_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RADIUSServerProfilesListResponse]:
+ """List RADIUS server profiles
+
+ Retreive a list of RADIUS server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_radius_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RADIUSServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_radius_server_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List RADIUS server profiles
+
+ Retreive a list of RADIUS server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_radius_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RADIUSServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_radius_server_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/radius-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_radius_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ radius_server_profiles: Annotated[Optional[RadiusServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RadiusServerProfiles:
+ """Update a RADIUS server profile
+
+ Update an existing RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param radius_server_profiles: OK
+ :type radius_server_profiles: RadiusServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_radius_server_profiles_by_id_serialize(
+ id=id,
+ radius_server_profiles=radius_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_radius_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ radius_server_profiles: Annotated[Optional[RadiusServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RadiusServerProfiles]:
+ """Update a RADIUS server profile
+
+ Update an existing RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param radius_server_profiles: OK
+ :type radius_server_profiles: RadiusServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_radius_server_profiles_by_id_serialize(
+ id=id,
+ radius_server_profiles=radius_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_radius_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ radius_server_profiles: Annotated[Optional[RadiusServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a RADIUS server profile
+
+ Update an existing RADIUS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param radius_server_profiles: OK
+ :type radius_server_profiles: RadiusServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_radius_server_profiles_by_id_serialize(
+ id=id,
+ radius_server_profiles=radius_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RadiusServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_radius_server_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single radius_server_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_radius_server_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_radius_server_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_radius_server_profiles_by_id_serialize(
+ self,
+ id,
+ radius_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if radius_server_profiles is not None:
+ _body_params = radius_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/radius-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/saml_server_profiles_api.py b/scm/identity_services/api/saml_server_profiles_api.py
new file mode 100644
index 00000000..05fe9527
--- /dev/null
+++ b/scm/identity_services/api/saml_server_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.saml_server_profiles_list_response import SAMLServerProfilesListResponse
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SAMLServerProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_saml_server_profiles(
+ self,
+ saml_server_profiles: Annotated[Optional[SamlServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SamlServerProfiles:
+ """Create a SAML server profile
+
+ Create a new SAML server profile.
+
+ :param saml_server_profiles: Created
+ :type saml_server_profiles: SamlServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_saml_server_profiles_serialize(
+ saml_server_profiles=saml_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_saml_server_profiles_with_http_info(
+ self,
+ saml_server_profiles: Annotated[Optional[SamlServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SamlServerProfiles]:
+ """Create a SAML server profile
+
+ Create a new SAML server profile.
+
+ :param saml_server_profiles: Created
+ :type saml_server_profiles: SamlServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_saml_server_profiles_serialize(
+ saml_server_profiles=saml_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_saml_server_profiles_without_preload_content(
+ self,
+ saml_server_profiles: Annotated[Optional[SamlServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a SAML server profile
+
+ Create a new SAML server profile.
+
+ :param saml_server_profiles: Created
+ :type saml_server_profiles: SamlServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_saml_server_profiles_serialize(
+ saml_server_profiles=saml_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_saml_server_profiles_serialize(
+ self,
+ saml_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if saml_server_profiles is not None:
+ _body_params = saml_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/saml-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_saml_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a SAML server profile
+
+ Delete a SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_saml_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_saml_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a SAML server profile
+
+ Delete a SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_saml_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_saml_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a SAML server profile
+
+ Delete a SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_saml_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_saml_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/saml-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_saml_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SamlServerProfiles:
+ """Get a SAML server profile
+
+ Get an existing SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_saml_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_saml_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SamlServerProfiles]:
+ """Get a SAML server profile
+
+ Get an existing SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_saml_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_saml_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a SAML server profile
+
+ Get an existing SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_saml_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_saml_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/saml-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_saml_server_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SAMLServerProfilesListResponse:
+ """List SAML server profiles
+
+ Retrieve a list of SAML server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_saml_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SAMLServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_saml_server_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SAMLServerProfilesListResponse]:
+ """List SAML server profiles
+
+ Retrieve a list of SAML server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_saml_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SAMLServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_saml_server_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List SAML server profiles
+
+ Retrieve a list of SAML server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_saml_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SAMLServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_saml_server_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/saml-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_saml_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ saml_server_profiles: Annotated[Optional[SamlServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SamlServerProfiles:
+ """Update a SAML server profile
+
+ Update an existing SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param saml_server_profiles: OK
+ :type saml_server_profiles: SamlServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_saml_server_profiles_by_id_serialize(
+ id=id,
+ saml_server_profiles=saml_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_saml_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ saml_server_profiles: Annotated[Optional[SamlServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SamlServerProfiles]:
+ """Update a SAML server profile
+
+ Update an existing SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param saml_server_profiles: OK
+ :type saml_server_profiles: SamlServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_saml_server_profiles_by_id_serialize(
+ id=id,
+ saml_server_profiles=saml_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_saml_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ saml_server_profiles: Annotated[Optional[SamlServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a SAML server profile
+
+ Update an existing SAML server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param saml_server_profiles: OK
+ :type saml_server_profiles: SamlServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_saml_server_profiles_by_id_serialize(
+ id=id,
+ saml_server_profiles=saml_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SamlServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_saml_server_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single saml_server_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_saml_server_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_saml_server_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_saml_server_profiles_by_id_serialize(
+ self,
+ id,
+ saml_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if saml_server_profiles is not None:
+ _body_params = saml_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/saml-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/scep_profiles_api.py b/scm/identity_services/api/scep_profiles_api.py
new file mode 100644
index 00000000..6c0d9f2f
--- /dev/null
+++ b/scm/identity_services/api/scep_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.scep_profiles_list_response import SCEPProfilesListResponse
+from scm.identity_services.models.scep_profiles import ScepProfiles
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SCEPProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_scep_profiles(
+ self,
+ scep_profiles: Annotated[Optional[ScepProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ScepProfiles:
+ """Create a SCEP profile
+
+ Create a new SCEP profile.
+
+ :param scep_profiles: Created
+ :type scep_profiles: ScepProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_scep_profiles_serialize(
+ scep_profiles=scep_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_scep_profiles_with_http_info(
+ self,
+ scep_profiles: Annotated[Optional[ScepProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ScepProfiles]:
+ """Create a SCEP profile
+
+ Create a new SCEP profile.
+
+ :param scep_profiles: Created
+ :type scep_profiles: ScepProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_scep_profiles_serialize(
+ scep_profiles=scep_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_scep_profiles_without_preload_content(
+ self,
+ scep_profiles: Annotated[Optional[ScepProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a SCEP profile
+
+ Create a new SCEP profile.
+
+ :param scep_profiles: Created
+ :type scep_profiles: ScepProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_scep_profiles_serialize(
+ scep_profiles=scep_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_scep_profiles_serialize(
+ self,
+ scep_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if scep_profiles is not None:
+ _body_params = scep_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/scep-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_scep_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a SCEP profile
+
+ Delete a SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_scep_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_scep_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a SCEP profile
+
+ Delete a SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_scep_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_scep_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a SCEP profile
+
+ Delete a SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_scep_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_scep_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/scep-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_scep_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ScepProfiles:
+ """Get a SCEP profile
+
+ Get an existing SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_scep_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_scep_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ScepProfiles]:
+ """Get a SCEP profile
+
+ Get an existing SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_scep_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_scep_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a SCEP profile
+
+ Get an existing SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_scep_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_scep_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/scep-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_scep_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SCEPProfilesListResponse:
+ """List SCEP profiles
+
+ Retrieve a list of SCEP profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_scep_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SCEPProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_scep_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SCEPProfilesListResponse]:
+ """List SCEP profiles
+
+ Retrieve a list of SCEP profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_scep_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SCEPProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_scep_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List SCEP profiles
+
+ Retrieve a list of SCEP profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_scep_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SCEPProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_scep_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/scep-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_scep_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ scep_profiles: Annotated[Optional[ScepProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ScepProfiles:
+ """Update a SCEP profile
+
+ Update an existing SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param scep_profiles: OK
+ :type scep_profiles: ScepProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_scep_profiles_by_id_serialize(
+ id=id,
+ scep_profiles=scep_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_scep_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ scep_profiles: Annotated[Optional[ScepProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ScepProfiles]:
+ """Update a SCEP profile
+
+ Update an existing SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param scep_profiles: OK
+ :type scep_profiles: ScepProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_scep_profiles_by_id_serialize(
+ id=id,
+ scep_profiles=scep_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_scep_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ scep_profiles: Annotated[Optional[ScepProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a SCEP profile
+
+ Update an existing SCEP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param scep_profiles: OK
+ :type scep_profiles: ScepProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_scep_profiles_by_id_serialize(
+ id=id,
+ scep_profiles=scep_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ScepProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_scep_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single scep_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_scep_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_scep_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_scep_profiles_by_id_serialize(
+ self,
+ id,
+ scep_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if scep_profiles is not None:
+ _body_params = scep_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/scep-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/tacacs_server_profiles_api.py b/scm/identity_services/api/tacacs_server_profiles_api.py
new file mode 100644
index 00000000..17a47a47
--- /dev/null
+++ b/scm/identity_services/api/tacacs_server_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.tacacs_server_profiles_list_response import TACACSServerProfilesListResponse
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TACACSServerProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_tacacs_server_profiles(
+ self,
+ tacacs_server_profiles: Annotated[Optional[TacacsServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TacacsServerProfiles:
+ """Create a TACACS server profile
+
+ Create a new TACACS server profile.
+
+ :param tacacs_server_profiles: Created
+ :type tacacs_server_profiles: TacacsServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tacacs_server_profiles_serialize(
+ tacacs_server_profiles=tacacs_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_tacacs_server_profiles_with_http_info(
+ self,
+ tacacs_server_profiles: Annotated[Optional[TacacsServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TacacsServerProfiles]:
+ """Create a TACACS server profile
+
+ Create a new TACACS server profile.
+
+ :param tacacs_server_profiles: Created
+ :type tacacs_server_profiles: TacacsServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tacacs_server_profiles_serialize(
+ tacacs_server_profiles=tacacs_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_tacacs_server_profiles_without_preload_content(
+ self,
+ tacacs_server_profiles: Annotated[Optional[TacacsServerProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a TACACS server profile
+
+ Create a new TACACS server profile.
+
+ :param tacacs_server_profiles: Created
+ :type tacacs_server_profiles: TacacsServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tacacs_server_profiles_serialize(
+ tacacs_server_profiles=tacacs_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_tacacs_server_profiles_serialize(
+ self,
+ tacacs_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tacacs_server_profiles is not None:
+ _body_params = tacacs_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/tacacs-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tacacs_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a TACACS server profile
+
+ Delete a TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tacacs_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a TACACS server profile
+
+ Delete a TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tacacs_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a TACACS server profile
+
+ Delete a TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_tacacs_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/tacacs-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_tacacs_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TacacsServerProfiles:
+ """Get a TACACS server profile
+
+ Get an existing TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_tacacs_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TacacsServerProfiles]:
+ """Get a TACACS server profile
+
+ Get an existing TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_tacacs_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a TACACS server profile
+
+ Get an existing TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_tacacs_server_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tacacs-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_tacacs_server_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TACACSServerProfilesListResponse:
+ """List TACACS server profiles
+
+ Retrieve a list of TACACS server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tacacs_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TACACSServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_tacacs_server_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TACACSServerProfilesListResponse]:
+ """List TACACS server profiles
+
+ Retrieve a list of TACACS server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tacacs_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TACACSServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_tacacs_server_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List TACACS server profiles
+
+ Retrieve a list of TACACS server profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tacacs_server_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TACACSServerProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_tacacs_server_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tacacs-server-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_tacacs_server_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tacacs_server_profiles: Annotated[Optional[TacacsServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TacacsServerProfiles:
+ """Update a TACACS server profile
+
+ Update an existing TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tacacs_server_profiles: OK
+ :type tacacs_server_profiles: TacacsServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ tacacs_server_profiles=tacacs_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_tacacs_server_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tacacs_server_profiles: Annotated[Optional[TacacsServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TacacsServerProfiles]:
+ """Update a TACACS server profile
+
+ Update an existing TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tacacs_server_profiles: OK
+ :type tacacs_server_profiles: TacacsServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ tacacs_server_profiles=tacacs_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_tacacs_server_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tacacs_server_profiles: Annotated[Optional[TacacsServerProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a TACACS server profile
+
+ Update an existing TACACS server profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tacacs_server_profiles: OK
+ :type tacacs_server_profiles: TacacsServerProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tacacs_server_profiles_by_id_serialize(
+ id=id,
+ tacacs_server_profiles=tacacs_server_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TacacsServerProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_tacacs_server_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single tacacs_server_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_tacacs_server_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_tacacs_server_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_tacacs_server_profiles_by_id_serialize(
+ self,
+ id,
+ tacacs_server_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tacacs_server_profiles is not None:
+ _body_params = tacacs_server_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/tacacs-server-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/tls_service_profiles_api.py b/scm/identity_services/api/tls_service_profiles_api.py
new file mode 100644
index 00000000..5839efb0
--- /dev/null
+++ b/scm/identity_services/api/tls_service_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.tls_service_profiles_list_response import TLSServiceProfilesListResponse
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TLSServiceProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_tls_service_profiles(
+ self,
+ tls_service_profiles: Annotated[Optional[TlsServiceProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TlsServiceProfiles:
+ """Create a TLS service profile
+
+ Create a new TLS service profile.
+
+ :param tls_service_profiles: Created
+ :type tls_service_profiles: TlsServiceProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tls_service_profiles_serialize(
+ tls_service_profiles=tls_service_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_tls_service_profiles_with_http_info(
+ self,
+ tls_service_profiles: Annotated[Optional[TlsServiceProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TlsServiceProfiles]:
+ """Create a TLS service profile
+
+ Create a new TLS service profile.
+
+ :param tls_service_profiles: Created
+ :type tls_service_profiles: TlsServiceProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tls_service_profiles_serialize(
+ tls_service_profiles=tls_service_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_tls_service_profiles_without_preload_content(
+ self,
+ tls_service_profiles: Annotated[Optional[TlsServiceProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a TLS service profile
+
+ Create a new TLS service profile.
+
+ :param tls_service_profiles: Created
+ :type tls_service_profiles: TlsServiceProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tls_service_profiles_serialize(
+ tls_service_profiles=tls_service_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_tls_service_profiles_serialize(
+ self,
+ tls_service_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tls_service_profiles is not None:
+ _body_params = tls_service_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/tls-service-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tls_service_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a TLS service profile
+
+ Delete a TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tls_service_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tls_service_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a TLS service profile
+
+ Delete a TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tls_service_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tls_service_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a TLS service profile
+
+ Delete a TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tls_service_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_tls_service_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/tls-service-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_tls_service_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TlsServiceProfiles:
+ """Get a TLS service profile
+
+ Get an existing TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tls_service_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_tls_service_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TlsServiceProfiles]:
+ """Get a TLS service profile
+
+ Get an existing TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tls_service_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_tls_service_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a TLS service profile
+
+ Get an existing TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tls_service_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_tls_service_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tls-service-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_tls_service_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TLSServiceProfilesListResponse:
+ """List TLS service profiles
+
+ Retrieve a list of TLS service profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tls_service_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TLSServiceProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_tls_service_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TLSServiceProfilesListResponse]:
+ """List TLS service profiles
+
+ Retrieve a list of TLS service profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tls_service_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TLSServiceProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_tls_service_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List TLS service profiles
+
+ Retrieve a list of TLS service profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tls_service_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TLSServiceProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_tls_service_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tls-service-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_tls_service_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tls_service_profiles: Annotated[Optional[TlsServiceProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TlsServiceProfiles:
+ """Update a TLS service profile
+
+ Update an existing TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tls_service_profiles: OK
+ :type tls_service_profiles: TlsServiceProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tls_service_profiles_by_id_serialize(
+ id=id,
+ tls_service_profiles=tls_service_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_tls_service_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tls_service_profiles: Annotated[Optional[TlsServiceProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TlsServiceProfiles]:
+ """Update a TLS service profile
+
+ Update an existing TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tls_service_profiles: OK
+ :type tls_service_profiles: TlsServiceProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tls_service_profiles_by_id_serialize(
+ id=id,
+ tls_service_profiles=tls_service_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_tls_service_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tls_service_profiles: Annotated[Optional[TlsServiceProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a TLS service profile
+
+ Update an existing TLS service profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tls_service_profiles: OK
+ :type tls_service_profiles: TlsServiceProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tls_service_profiles_by_id_serialize(
+ id=id,
+ tls_service_profiles=tls_service_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TlsServiceProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_tls_service_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single tls_service_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_tls_service_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_tls_service_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_tls_service_profiles_by_id_serialize(
+ self,
+ id,
+ tls_service_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tls_service_profiles is not None:
+ _body_params = tls_service_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/tls-service-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api/trusted_certificate_authorities_api.py b/scm/identity_services/api/trusted_certificate_authorities_api.py
new file mode 100644
index 00000000..24b871c6
--- /dev/null
+++ b/scm/identity_services/api/trusted_certificate_authorities_api.py
@@ -0,0 +1,467 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.trusted_certificate_authorities_list_response import TrustedCertificateAuthoritiesListResponse
+
+from scm.identity_services.api_client import ApiClient, RequestSerialized
+from scm.identity_services.api_response import ApiResponse
+from scm.identity_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TrustedCertificateAuthoritiesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def list_trusted_certificate_authorities(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TrustedCertificateAuthoritiesListResponse:
+ """List trusted certificate authorities
+
+ Retrieve a list of trusted certificate authorities.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_trusted_certificate_authorities_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrustedCertificateAuthoritiesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_trusted_certificate_authorities_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TrustedCertificateAuthoritiesListResponse]:
+ """List trusted certificate authorities
+
+ Retrieve a list of trusted certificate authorities.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_trusted_certificate_authorities_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrustedCertificateAuthoritiesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_trusted_certificate_authorities_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List trusted certificate authorities
+
+ Retrieve a list of trusted certificate authorities.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_trusted_certificate_authorities_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TrustedCertificateAuthoritiesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_trusted_certificate_authorities(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single trusted_certificate_authorities object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_trusted_certificate_authorities(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_trusted_certificate_authorities(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _list_trusted_certificate_authorities_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/trusted-certificate-authorities',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/identity_services/api_client.py b/scm/identity_services/api_client.py
new file mode 100644
index 00000000..f14d436d
--- /dev/null
+++ b/scm/identity_services/api_client.py
@@ -0,0 +1,798 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import datetime
+from dateutil.parser import parse
+from enum import Enum
+import decimal
+import json
+import mimetypes
+import os
+import re
+import tempfile
+
+from urllib.parse import quote
+from typing import Tuple, Optional, List, Dict, Union
+from pydantic import SecretStr
+
+from scm.identity_services.configuration import Configuration
+from scm.identity_services.api_response import ApiResponse, T as ApiResponseT
+import scm.identity_services.models
+from scm.identity_services import rest
+from scm.identity_services.exceptions import (
+ ApiValueError,
+ ApiException,
+ BadRequestException,
+ UnauthorizedException,
+ ForbiddenException,
+ NotFoundException,
+ ServiceException
+)
+
+RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]
+
+class ApiClient:
+ """Generic API client for OpenAPI client library builds.
+
+ OpenAPI generic API client. This client handles the client-
+ server communication, and is invariant across implementations. Specifics of
+ the methods and models for each application are generated from the OpenAPI
+ templates.
+
+ :param configuration: .Configuration object for this client
+ :param header_name: a header to pass when making calls to the API.
+ :param header_value: a header value to pass when making calls to
+ the API.
+ :param cookie: a cookie to include in the header when making calls
+ to the API
+ """
+
+ PRIMITIVE_TYPES = (float, bool, bytes, str, int)
+ NATIVE_TYPES_MAPPING = {
+ 'int': int,
+ 'long': int, # TODO remove as only py3 is supported?
+ 'float': float,
+ 'str': str,
+ 'bool': bool,
+ 'date': datetime.date,
+ 'datetime': datetime.datetime,
+ 'decimal': decimal.Decimal,
+ 'object': object,
+ }
+ _pool = None
+
+ def __init__(
+ self,
+ configuration=None,
+ header_name=None,
+ header_value=None,
+ cookie=None
+ ) -> None:
+ # use default configuration if none is provided
+ if configuration is None:
+ configuration = Configuration.get_default()
+ self.configuration = configuration
+
+ self.rest_client = rest.RESTClientObject(configuration)
+ self.default_headers = {}
+ if header_name is not None:
+ self.default_headers[header_name] = header_value
+ self.cookie = cookie
+ # Set default User-Agent.
+ self.user_agent = 'OpenAPI-Generator/1.0.0/python'
+ self.client_side_validation = configuration.client_side_validation
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ pass
+
+ @property
+ def user_agent(self):
+ """User agent for this API client"""
+ return self.default_headers['User-Agent']
+
+ @user_agent.setter
+ def user_agent(self, value):
+ self.default_headers['User-Agent'] = value
+
+ def set_default_header(self, header_name, header_value):
+ self.default_headers[header_name] = header_value
+
+
+ _default = None
+
+ @classmethod
+ def get_default(cls):
+ """Return new instance of ApiClient.
+
+ This method returns newly created, based on default constructor,
+ object of ApiClient class or returns a copy of default
+ ApiClient.
+
+ :return: The ApiClient object.
+ """
+ if cls._default is None:
+ cls._default = ApiClient()
+ return cls._default
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of ApiClient.
+
+ It stores default ApiClient.
+
+ :param default: object of ApiClient.
+ """
+ cls._default = default
+
+ def param_serialize(
+ self,
+ method,
+ resource_path,
+ path_params=None,
+ query_params=None,
+ header_params=None,
+ body=None,
+ post_params=None,
+ files=None, auth_settings=None,
+ collection_formats=None,
+ _host=None,
+ _request_auth=None
+ ) -> RequestSerialized:
+
+ """Builds the HTTP request params needed by the request.
+ :param method: Method to call.
+ :param resource_path: Path to method endpoint.
+ :param path_params: Path parameters in the url.
+ :param query_params: Query parameters in the url.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param auth_settings list: Auth Settings names for the request.
+ :param files dict: key -> filename, value -> filepath,
+ for `multipart/form-data`.
+ :param collection_formats: dict of collection formats for path, query,
+ header, and post parameters.
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the authentication
+ in the spec for a single request.
+ :return: tuple of form (path, http_method, query_params, header_params,
+ body, post_params, files)
+ """
+
+ config = self.configuration
+
+ # header parameters
+ header_params = header_params or {}
+ header_params.update(self.default_headers)
+ if self.cookie:
+ header_params['Cookie'] = self.cookie
+ if header_params:
+ header_params = self.sanitize_for_serialization(header_params)
+ header_params = dict(
+ self.parameters_to_tuples(header_params,collection_formats)
+ )
+
+ # path parameters
+ if path_params:
+ path_params = self.sanitize_for_serialization(path_params)
+ path_params = self.parameters_to_tuples(
+ path_params,
+ collection_formats
+ )
+ for k, v in path_params:
+ # specified safe chars, encode everything
+ resource_path = resource_path.replace(
+ '{%s}' % k,
+ quote(str(v), safe=config.safe_chars_for_path_param)
+ )
+
+ # post parameters
+ if post_params or files:
+ post_params = post_params if post_params else []
+ post_params = self.sanitize_for_serialization(post_params)
+ post_params = self.parameters_to_tuples(
+ post_params,
+ collection_formats
+ )
+ if files:
+ post_params.extend(self.files_parameters(files))
+
+ # auth setting
+ self.update_params_for_auth(
+ header_params,
+ query_params,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=_request_auth
+ )
+
+ # body
+ if body:
+ body = self.sanitize_for_serialization(body)
+
+ # request url
+ if _host is None or self.configuration.ignore_operation_servers:
+ url = self.configuration.host + resource_path
+ else:
+ # use server/host defined in path or operation instead
+ url = _host + resource_path
+
+ # query parameters
+ if query_params:
+ query_params = self.sanitize_for_serialization(query_params)
+ url_query = self.parameters_to_url_query(
+ query_params,
+ collection_formats
+ )
+ url += "?" + url_query
+
+ return method, url, header_params, body, post_params
+
+
+ def call_api(
+ self,
+ method,
+ url,
+ header_params=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ) -> rest.RESTResponse:
+ """Makes the HTTP request (synchronous)
+ :param method: Method to call.
+ :param url: Path to method endpoint.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param _request_timeout: timeout setting for this request.
+ :return: RESTResponse
+ """
+
+ try:
+ # perform request and return response
+ response_data = self.rest_client.request(
+ method, url,
+ headers=header_params,
+ body=body, post_params=post_params,
+ _request_timeout=_request_timeout
+ )
+
+ except ApiException as e:
+ raise e
+
+ return response_data
+
+ def response_deserialize(
+ self,
+ response_data: rest.RESTResponse,
+ response_types_map: Optional[Dict[str, ApiResponseT]]=None
+ ) -> ApiResponse[ApiResponseT]:
+ """Deserializes response into an object.
+ :param response_data: RESTResponse object to be deserialized.
+ :param response_types_map: dict of response types.
+ :return: ApiResponse
+ """
+
+ msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
+ assert response_data.data is not None, msg
+
+ response_type = response_types_map.get(str(response_data.status), None)
+ if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
+ # if not found, look for '1XX', '2XX', etc.
+ response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
+
+ # deserialize response data
+ response_text = None
+ return_data = None
+ try:
+ if response_type == "bytearray":
+ return_data = response_data.data
+ elif response_type == "file":
+ return_data = self.__deserialize_file(response_data)
+ elif response_type is not None:
+ match = None
+ content_type = response_data.getheader('content-type')
+ if content_type is not None:
+ match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
+ encoding = match.group(1) if match else "utf-8"
+ response_text = response_data.data.decode(encoding)
+ return_data = self.deserialize(response_text, response_type, content_type)
+ finally:
+ if not 200 <= response_data.status <= 299:
+ raise ApiException.from_response(
+ http_resp=response_data,
+ body=response_text,
+ data=return_data,
+ )
+
+ return ApiResponse(
+ status_code = response_data.status,
+ data = return_data,
+ headers = response_data.getheaders(),
+ raw_data = response_data.data
+ )
+
+ def sanitize_for_serialization(self, obj):
+ """Builds a JSON POST object.
+
+ If obj is None, return None.
+ If obj is SecretStr, return obj.get_secret_value()
+ If obj is str, int, long, float, bool, return directly.
+ If obj is datetime.datetime, datetime.date
+ convert to string in iso8601 format.
+ If obj is decimal.Decimal return string representation.
+ If obj is list, sanitize each element in the list.
+ If obj is dict, return the dict.
+ If obj is OpenAPI model, return the properties dict.
+
+ :param obj: The data to serialize.
+ :return: The serialized form of data.
+ """
+ if obj is None:
+ return None
+ elif isinstance(obj, Enum):
+ return obj.value
+ elif isinstance(obj, SecretStr):
+ return obj.get_secret_value()
+ elif isinstance(obj, self.PRIMITIVE_TYPES):
+ return obj
+ elif isinstance(obj, list):
+ return [
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ ]
+ elif isinstance(obj, tuple):
+ return tuple(
+ self.sanitize_for_serialization(sub_obj) for sub_obj in obj
+ )
+ elif isinstance(obj, (datetime.datetime, datetime.date)):
+ return obj.isoformat()
+ elif isinstance(obj, decimal.Decimal):
+ return str(obj)
+
+ elif isinstance(obj, dict):
+ obj_dict = obj
+ else:
+ # Convert model obj to dict except
+ # attributes `openapi_types`, `attribute_map`
+ # and attributes which value is not None.
+ # Convert attribute name to json key in
+ # model definition for request.
+ if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
+ obj_dict = obj.to_dict()
+ else:
+ obj_dict = obj.__dict__
+
+ return {
+ key: self.sanitize_for_serialization(val)
+ for key, val in obj_dict.items()
+ }
+
+ def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]):
+ """Deserializes response into an object.
+
+ :param response: RESTResponse object to be deserialized.
+ :param response_type: class literal for
+ deserialized object, or string of class name.
+ :param content_type: content type of response.
+
+ :return: deserialized object.
+ """
+
+ # fetch data from response object
+ if content_type is None:
+ try:
+ data = json.loads(response_text)
+ except ValueError:
+ data = response_text
+ elif re.match(r'^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)', content_type, re.IGNORECASE):
+ if response_text == "":
+ data = ""
+ else:
+ data = json.loads(response_text)
+ elif re.match(r'^text\/[a-z.+-]+\s*(;|$)', content_type, re.IGNORECASE):
+ data = response_text
+ else:
+ raise ApiException(
+ status=0,
+ reason="Unsupported content type: {0}".format(content_type)
+ )
+
+ return self.__deserialize(data, response_type)
+
+ def __deserialize(self, data, klass):
+ """Deserializes dict, list, str into an object.
+
+ :param data: dict, list or str.
+ :param klass: class literal, or string of class name.
+
+ :return: object.
+ """
+ if data is None:
+ return None
+
+ if isinstance(klass, str):
+ if klass.startswith('List['):
+ m = re.match(r'List\[(.*)]', klass)
+ assert m is not None, "Malformed List type definition"
+ sub_kls = m.group(1)
+ return [self.__deserialize(sub_data, sub_kls)
+ for sub_data in data]
+
+ if klass.startswith('Dict['):
+ m = re.match(r'Dict\[([^,]*), (.*)]', klass)
+ assert m is not None, "Malformed Dict type definition"
+ sub_kls = m.group(2)
+ return {k: self.__deserialize(v, sub_kls)
+ for k, v in data.items()}
+
+ # convert str to class
+ if klass in self.NATIVE_TYPES_MAPPING:
+ klass = self.NATIVE_TYPES_MAPPING[klass]
+ else:
+ klass = getattr(scm.identity_services.models, klass)
+
+ if klass in self.PRIMITIVE_TYPES:
+ return self.__deserialize_primitive(data, klass)
+ elif klass == object:
+ return self.__deserialize_object(data)
+ elif klass == datetime.date:
+ return self.__deserialize_date(data)
+ elif klass == datetime.datetime:
+ return self.__deserialize_datetime(data)
+ elif klass == decimal.Decimal:
+ return decimal.Decimal(data)
+ elif issubclass(klass, Enum):
+ return self.__deserialize_enum(data, klass)
+ else:
+ return self.__deserialize_model(data, klass)
+
+ def parameters_to_tuples(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: Parameters as list of tuples, collections formatted
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, value) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(str(value) for value in v)))
+ else:
+ new_params.append((k, v))
+ return new_params
+
+ def parameters_to_url_query(self, params, collection_formats):
+ """Get parameters as list of tuples, formatting collections.
+
+ :param params: Parameters as dict or list of two-tuples
+ :param dict collection_formats: Parameter collection formats
+ :return: URL query string (e.g. a=Hello%20World&b=123)
+ """
+ new_params: List[Tuple[str, str]] = []
+ if collection_formats is None:
+ collection_formats = {}
+ for k, v in params.items() if isinstance(params, dict) else params:
+ if isinstance(v, bool):
+ v = str(v).lower()
+ if isinstance(v, (int, float)):
+ v = str(v)
+ if isinstance(v, dict):
+ v = json.dumps(v)
+
+ if k in collection_formats:
+ collection_format = collection_formats[k]
+ if collection_format == 'multi':
+ new_params.extend((k, str(value)) for value in v)
+ else:
+ if collection_format == 'ssv':
+ delimiter = ' '
+ elif collection_format == 'tsv':
+ delimiter = '\t'
+ elif collection_format == 'pipes':
+ delimiter = '|'
+ else: # csv is the default
+ delimiter = ','
+ new_params.append(
+ (k, delimiter.join(quote(str(value)) for value in v))
+ )
+ else:
+ new_params.append((k, quote(str(v))))
+
+ return "&".join(["=".join(map(str, item)) for item in new_params])
+
+ def files_parameters(
+ self,
+ files: Dict[str, Union[str, bytes, List[str], List[bytes], Tuple[str, bytes]]],
+ ):
+ """Builds form parameters.
+
+ :param files: File parameters.
+ :return: Form parameters with files.
+ """
+ params = []
+ for k, v in files.items():
+ if isinstance(v, str):
+ with open(v, 'rb') as f:
+ filename = os.path.basename(f.name)
+ filedata = f.read()
+ elif isinstance(v, bytes):
+ filename = k
+ filedata = v
+ elif isinstance(v, tuple):
+ filename, filedata = v
+ elif isinstance(v, list):
+ for file_param in v:
+ params.extend(self.files_parameters({k: file_param}))
+ continue
+ else:
+ raise ValueError("Unsupported file value")
+ mimetype = (
+ mimetypes.guess_type(filename)[0]
+ or 'application/octet-stream'
+ )
+ params.append(
+ tuple([k, tuple([filename, filedata, mimetype])])
+ )
+ return params
+
+ def select_header_accept(self, accepts: List[str]) -> Optional[str]:
+ """Returns `Accept` based on an array of accepts provided.
+
+ :param accepts: List of headers.
+ :return: Accept (e.g. application/json).
+ """
+ if not accepts:
+ return None
+
+ for accept in accepts:
+ if re.search('json', accept, re.IGNORECASE):
+ return accept
+
+ return accepts[0]
+
+ def select_header_content_type(self, content_types):
+ """Returns `Content-Type` based on an array of content_types provided.
+
+ :param content_types: List of content-types.
+ :return: Content-Type (e.g. application/json).
+ """
+ if not content_types:
+ return None
+
+ for content_type in content_types:
+ if re.search('json', content_type, re.IGNORECASE):
+ return content_type
+
+ return content_types[0]
+
+ def update_params_for_auth(
+ self,
+ headers,
+ queries,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=None
+ ) -> None:
+ """Updates header and query params based on authentication setting.
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :param auth_settings: Authentication setting identifiers list.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param request_auth: if set, the provided settings will
+ override the token in the configuration.
+ """
+ if not auth_settings:
+ return
+
+ if request_auth:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ request_auth
+ )
+ else:
+ for auth in auth_settings:
+ auth_setting = self.configuration.auth_settings().get(auth)
+ if auth_setting:
+ self._apply_auth_params(
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ )
+
+ def _apply_auth_params(
+ self,
+ headers,
+ queries,
+ resource_path,
+ method,
+ body,
+ auth_setting
+ ) -> None:
+ """Updates the request parameters based on a single auth_setting
+
+ :param headers: Header parameters dict to be updated.
+ :param queries: Query parameters tuple list to be updated.
+ :resource_path: A string representation of the HTTP request resource path.
+ :method: A string representation of the HTTP request method.
+ :body: A object representing the body of the HTTP request.
+ The object type is the return value of sanitize_for_serialization().
+ :param auth_setting: auth settings for the endpoint
+ """
+ if auth_setting['in'] == 'cookie':
+ headers['Cookie'] = auth_setting['value']
+ elif auth_setting['in'] == 'header':
+ if auth_setting['type'] != 'http-signature':
+ headers[auth_setting['key']] = auth_setting['value']
+ elif auth_setting['in'] == 'query':
+ queries.append((auth_setting['key'], auth_setting['value']))
+ else:
+ raise ApiValueError(
+ 'Authentication token must be in `query` or `header`'
+ )
+
+ def __deserialize_file(self, response):
+ """Deserializes body to file
+
+ Saves response body into a file in a temporary folder,
+ using the filename from the `Content-Disposition` header if provided.
+
+ handle file downloading
+ save response body into a tmp file and return the instance
+
+ :param response: RESTResponse.
+ :return: file path.
+ """
+ fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
+ os.close(fd)
+ os.remove(path)
+
+ content_disposition = response.getheader("Content-Disposition")
+ if content_disposition:
+ m = re.search(
+ r'filename=[\'"]?([^\'"\s]+)[\'"]?',
+ content_disposition
+ )
+ assert m is not None, "Unexpected 'content-disposition' header value"
+ filename = m.group(1)
+ path = os.path.join(os.path.dirname(path), filename)
+
+ with open(path, "wb") as f:
+ f.write(response.data)
+
+ return path
+
+ def __deserialize_primitive(self, data, klass):
+ """Deserializes string to primitive type.
+
+ :param data: str.
+ :param klass: class literal.
+
+ :return: int, long, float, str, bool.
+ """
+ try:
+ return klass(data)
+ except UnicodeEncodeError:
+ return str(data)
+ except TypeError:
+ return data
+
+ def __deserialize_object(self, value):
+ """Return an original value.
+
+ :return: object.
+ """
+ return value
+
+ def __deserialize_date(self, string):
+ """Deserializes string to date.
+
+ :param string: str.
+ :return: date.
+ """
+ try:
+ return parse(string).date()
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason="Failed to parse `{0}` as date object".format(string)
+ )
+
+ def __deserialize_datetime(self, string):
+ """Deserializes string to datetime.
+
+ The string should be in iso8601 datetime format.
+
+ :param string: str.
+ :return: datetime.
+ """
+ try:
+ return parse(string)
+ except ImportError:
+ return string
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as datetime object"
+ .format(string)
+ )
+ )
+
+ def __deserialize_enum(self, data, klass):
+ """Deserializes primitive type to enum.
+
+ :param data: primitive type.
+ :param klass: class literal.
+ :return: enum value.
+ """
+ try:
+ return klass(data)
+ except ValueError:
+ raise rest.ApiException(
+ status=0,
+ reason=(
+ "Failed to parse `{0}` as `{1}`"
+ .format(data, klass)
+ )
+ )
+
+ def __deserialize_model(self, data, klass):
+ """Deserializes list or dict to model.
+
+ :param data: dict, list.
+ :param klass: class literal.
+ :return: model object.
+ """
+
+ return klass.from_dict(data)
diff --git a/scm/identity_services/api_response.py b/scm/identity_services/api_response.py
new file mode 100644
index 00000000..9bc7c11f
--- /dev/null
+++ b/scm/identity_services/api_response.py
@@ -0,0 +1,21 @@
+"""API response object."""
+
+from __future__ import annotations
+from typing import Optional, Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+ """
+ API response object
+ """
+
+ status_code: StrictInt = Field(description="HTTP status code")
+ headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
+ data: T = Field(description="Deserialized data given the data type")
+ raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
+
+ model_config = {
+ "arbitrary_types_allowed": True
+ }
diff --git a/scm/identity_services/configuration.py b/scm/identity_services/configuration.py
new file mode 100644
index 00000000..4df4d7de
--- /dev/null
+++ b/scm/identity_services/configuration.py
@@ -0,0 +1,471 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import copy
+import logging
+from logging import FileHandler
+import multiprocessing
+import sys
+from typing import Optional
+import urllib3
+
+import http.client as httplib
+
+JSON_SCHEMA_VALIDATION_KEYWORDS = {
+ 'multipleOf', 'maximum', 'exclusiveMaximum',
+ 'minimum', 'exclusiveMinimum', 'maxLength',
+ 'minLength', 'pattern', 'maxItems', 'minItems'
+}
+
+class Configuration:
+ """This class contains various settings of the API client.
+
+ :param host: Base url.
+ :param ignore_operation_servers
+ Boolean to ignore operation servers for the API client.
+ Config will use `host` as the base url regardless of the operation servers.
+ :param api_key: Dict to store API key(s).
+ Each entry in the dict specifies an API key.
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is the API key secret.
+ :param api_key_prefix: Dict to store API prefix (e.g. Bearer).
+ The dict key is the name of the security scheme in the OAS specification.
+ The dict value is an API key prefix when generating the auth data.
+ :param username: Username for HTTP basic authentication.
+ :param password: Password for HTTP basic authentication.
+ :param access_token: Access token.
+ :param server_index: Index to servers configuration.
+ :param server_variables: Mapping with string values to replace variables in
+ templated server configuration. The validation of enums is performed for
+ variables with defined enum values before.
+ :param server_operation_index: Mapping from operation ID to an index to server
+ configuration.
+ :param server_operation_variables: Mapping from operation ID to a mapping with
+ string values to replace variables in templated server configuration.
+ The validation of enums is performed for variables with defined enum
+ values before.
+ :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
+ in PEM format.
+ :param retries: Number of retries for API requests.
+
+ :Example:
+ """
+
+ _default = None
+
+ def __init__(self, host=None,
+ api_key=None, api_key_prefix=None,
+ username=None, password=None,
+ access_token=None,
+ server_index=None, server_variables=None,
+ server_operation_index=None, server_operation_variables=None,
+ ignore_operation_servers=False,
+ ssl_ca_cert=None,
+ retries=None,
+ *,
+ debug: Optional[bool] = None
+ ) -> None:
+ """Constructor
+ """
+ self._base_path = "https://api.strata.paloaltonetworks.com/config/identity/v1" if host is None else host
+ """Default Base url
+ """
+ self.server_index = 0 if server_index is None and host is None else server_index
+ self.server_operation_index = server_operation_index or {}
+ """Default server index
+ """
+ self.server_variables = server_variables or {}
+ self.server_operation_variables = server_operation_variables or {}
+ """Default server variables
+ """
+ self.ignore_operation_servers = ignore_operation_servers
+ """Ignore operation servers
+ """
+ self.temp_folder_path = None
+ """Temp file folder for downloading files
+ """
+ # Authentication Settings
+ self.api_key = {}
+ if api_key:
+ self.api_key = api_key
+ """dict to store API key(s)
+ """
+ self.api_key_prefix = {}
+ if api_key_prefix:
+ self.api_key_prefix = api_key_prefix
+ """dict to store API prefix (e.g. Bearer)
+ """
+ self.refresh_api_key_hook = None
+ """function hook to refresh API key if expired
+ """
+ self.username = username
+ """Username for HTTP basic authentication
+ """
+ self.password = password
+ """Password for HTTP basic authentication
+ """
+ self.access_token = access_token
+ """Access token
+ """
+ self.logger = {}
+ """Logging Settings
+ """
+ self.logger["package_logger"] = logging.getLogger("scm.identity_services")
+ self.logger["urllib3_logger"] = logging.getLogger("urllib3")
+ self.logger_format = '%(asctime)s %(levelname)s %(message)s'
+ """Log format
+ """
+ self.logger_stream_handler = None
+ """Log stream handler
+ """
+ self.logger_file_handler: Optional[FileHandler] = None
+ """Log file handler
+ """
+ self.logger_file = None
+ """Debug file location
+ """
+ if debug is not None:
+ self.debug = debug
+ else:
+ self.__debug = False
+ """Debug switch
+ """
+
+ self.verify_ssl = True
+ """SSL/TLS verification
+ Set this to false to skip verifying SSL certificate when calling API
+ from https server.
+ """
+ self.ssl_ca_cert = ssl_ca_cert
+ """Set this to customize the certificate file to verify the peer.
+ """
+ self.cert_file = None
+ """client certificate file
+ """
+ self.key_file = None
+ """client key file
+ """
+ self.assert_hostname = None
+ """Set this to True/False to enable/disable SSL hostname verification.
+ """
+ self.tls_server_name = None
+ """SSL/TLS Server Name Indication (SNI)
+ Set this to the SNI value expected by the server.
+ """
+
+ self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
+ """urllib3 connection pool's maximum number of connections saved
+ per pool. urllib3 uses 1 connection as default value, but this is
+ not the best value when you are making a lot of possibly parallel
+ requests to the same host, which is often the case here.
+ cpu_count * 5 is used as default value to increase performance.
+ """
+
+ self.proxy: Optional[str] = None
+ """Proxy URL
+ """
+ self.proxy_headers = None
+ """Proxy headers
+ """
+ self.safe_chars_for_path_param = ''
+ """Safe chars for path_param
+ """
+ self.retries = retries
+ """Adding retries to override urllib3 default value 3
+ """
+ # Enable client side validation
+ self.client_side_validation = True
+
+ self.socket_options = None
+ """Options to pass down to the underlying urllib3 socket
+ """
+
+ self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z"
+ """datetime format
+ """
+
+ self.date_format = "%Y-%m-%d"
+ """date format
+ """
+
+ def __deepcopy__(self, memo):
+ cls = self.__class__
+ result = cls.__new__(cls)
+ memo[id(self)] = result
+ for k, v in self.__dict__.items():
+ if k not in ('logger', 'logger_file_handler'):
+ setattr(result, k, copy.deepcopy(v, memo))
+ # shallow copy of loggers
+ result.logger = copy.copy(self.logger)
+ # use setters to configure loggers
+ result.logger_file = self.logger_file
+ result.debug = self.debug
+ return result
+
+ def __setattr__(self, name, value):
+ object.__setattr__(self, name, value)
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of configuration.
+
+ It stores default configuration, which can be
+ returned by get_default_copy method.
+
+ :param default: object of Configuration
+ """
+ cls._default = default
+
+ @classmethod
+ def get_default_copy(cls):
+ """Deprecated. Please use `get_default` instead.
+
+ Deprecated. Please use `get_default` instead.
+
+ :return: The configuration object.
+ """
+ return cls.get_default()
+
+ @classmethod
+ def get_default(cls):
+ """Return the default configuration.
+
+ This method returns newly created, based on default constructor,
+ object of Configuration class or returns a copy of default
+ configuration.
+
+ :return: The configuration object.
+ """
+ if cls._default is None:
+ cls._default = Configuration()
+ return cls._default
+
+ @property
+ def logger_file(self):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ return self.__logger_file
+
+ @logger_file.setter
+ def logger_file(self, value):
+ """The logger file.
+
+ If the logger_file is None, then add stream handler and remove file
+ handler. Otherwise, add file handler and remove stream handler.
+
+ :param value: The logger_file path.
+ :type: str
+ """
+ self.__logger_file = value
+ if self.__logger_file:
+ # If set logging file,
+ # then add file handler and remove stream handler.
+ self.logger_file_handler = logging.FileHandler(self.__logger_file)
+ self.logger_file_handler.setFormatter(self.logger_formatter)
+ for _, logger in self.logger.items():
+ logger.addHandler(self.logger_file_handler)
+
+ @property
+ def debug(self):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ return self.__debug
+
+ @debug.setter
+ def debug(self, value):
+ """Debug status
+
+ :param value: The debug status, True or False.
+ :type: bool
+ """
+ self.__debug = value
+ if self.__debug:
+ # if debug status is True, turn on debug logging
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.DEBUG)
+ # turn on httplib debug
+ httplib.HTTPConnection.debuglevel = 1
+ else:
+ # if debug status is False, turn off debug logging,
+ # setting log level to default `logging.WARNING`
+ for _, logger in self.logger.items():
+ logger.setLevel(logging.WARNING)
+ # turn off httplib debug
+ httplib.HTTPConnection.debuglevel = 0
+
+ @property
+ def logger_format(self):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ return self.__logger_format
+
+ @logger_format.setter
+ def logger_format(self, value):
+ """The logger format.
+
+ The logger_formatter will be updated when sets logger_format.
+
+ :param value: The format string.
+ :type: str
+ """
+ self.__logger_format = value
+ self.logger_formatter = logging.Formatter(self.__logger_format)
+
+ def get_api_key_with_prefix(self, identifier, alias=None):
+ """Gets API key (with prefix if set).
+
+ :param identifier: The identifier of apiKey.
+ :param alias: The alternative identifier of apiKey.
+ :return: The token for api key authentication.
+ """
+ if self.refresh_api_key_hook is not None:
+ self.refresh_api_key_hook(self)
+ key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
+ if key:
+ prefix = self.api_key_prefix.get(identifier)
+ if prefix:
+ return "%s %s" % (prefix, key)
+ else:
+ return key
+
+ def get_basic_auth_token(self):
+ """Gets HTTP basic authentication header (string).
+
+ :return: The token for basic HTTP authentication.
+ """
+ username = ""
+ if self.username is not None:
+ username = self.username
+ password = ""
+ if self.password is not None:
+ password = self.password
+ return urllib3.util.make_headers(
+ basic_auth=username + ':' + password
+ ).get('authorization')
+
+ def auth_settings(self):
+ """Gets Auth Settings dict for api client.
+
+ :return: The Auth Settings information dict.
+ """
+ auth = {}
+ if self.access_token is not None:
+ auth['scmOAuth'] = {
+ 'type': 'oauth2',
+ 'in': 'header',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ if self.access_token is not None:
+ auth['scmToken'] = {
+ 'type': 'bearer',
+ 'in': 'header',
+ 'format': 'JWT',
+ 'key': 'Authorization',
+ 'value': 'Bearer ' + self.access_token
+ }
+ return auth
+
+ def to_debug_report(self):
+ """Gets the essential information for debugging.
+
+ :return: The report for debugging.
+ """
+ return "Python SDK Debug Report:\n"\
+ "OS: {env}\n"\
+ "Python Version: {pyversion}\n"\
+ "Version of the API: 2.0.0\n"\
+ "SDK Package Version: 1.0.0".\
+ format(env=sys.platform, pyversion=sys.version)
+
+ def get_host_settings(self):
+ """Gets an array of host settings
+
+ :return: An array of host settings
+ """
+ return [
+ {
+ 'url': "https://api.strata.paloaltonetworks.com/config/identity/v1",
+ 'description': "Current",
+ },
+ {
+ 'url': "https://api.sase.paloaltonetworks.com/sse/config/v1",
+ 'description': "Legacy",
+ }
+ ]
+
+ def get_host_from_settings(self, index, variables=None, servers=None):
+ """Gets host URL based on the index and variables
+ :param index: array index of the host settings
+ :param variables: hash of variable and the corresponding value
+ :param servers: an array of host settings or None
+ :return: URL based on host settings
+ """
+ if index is None:
+ return self._base_path
+
+ variables = {} if variables is None else variables
+ servers = self.get_host_settings() if servers is None else servers
+
+ try:
+ server = servers[index]
+ except IndexError:
+ raise ValueError(
+ "Invalid index {0} when selecting the host settings. "
+ "Must be less than {1}".format(index, len(servers)))
+
+ url = server['url']
+
+ # go through variables and replace placeholders
+ for variable_name, variable in server.get('variables', {}).items():
+ used_value = variables.get(
+ variable_name, variable['default_value'])
+
+ if 'enum_values' in variable \
+ and used_value not in variable['enum_values']:
+ raise ValueError(
+ "The variable `{0}` in the host URL has invalid value "
+ "{1}. Must be {2}.".format(
+ variable_name, variables[variable_name],
+ variable['enum_values']))
+
+ url = url.replace("{" + variable_name + "}", used_value)
+
+ return url
+
+ @property
+ def host(self):
+ """Return generated host."""
+ return self.get_host_from_settings(self.server_index, variables=self.server_variables)
+
+ @host.setter
+ def host(self, value):
+ """Fix base path."""
+ self._base_path = value
+ self.server_index = None
diff --git a/scm/identity_services/docs/AuthenticationPortals.md b/scm/identity_services/docs/AuthenticationPortals.md
new file mode 100644
index 00000000..051903a4
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationPortals.md
@@ -0,0 +1,39 @@
+# AuthenticationPortals
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authentication_profile** | **str** | The authentication profile | [optional]
+**certificate_profile** | **str** | The certificate profile | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**gp_udp_port** | **int** | The UDP port for inbound authentication prompts | [optional]
+**id** | **str** | The UUID of the authentication portal | [optional] [readonly]
+**idle_timer** | **int** | The idle timeout value (minutes) | [optional]
+**redirect_host** | **str** | The authentication portal IP address or hostname |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**timer** | **int** | | [optional]
+**tls_service_profile** | **str** | The SSL/TLS service profile | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationPortals from a JSON string
+authentication_portals_instance = AuthenticationPortals.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationPortals.to_json())
+
+# convert the object into a dict
+authentication_portals_dict = authentication_portals_instance.to_dict()
+# create an instance of AuthenticationPortals from a dict
+authentication_portals_from_dict = AuthenticationPortals.from_dict(authentication_portals_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationPortalsApi.md b/scm/identity_services/docs/AuthenticationPortalsApi.md
new file mode 100644
index 00000000..5a39c9ff
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationPortalsApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.AuthenticationPortalsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_authentication_portals**](AuthenticationPortalsApi.md#create_authentication_portals) | **POST** /authentication-portals | Create an authentication portal
+[**delete_authentication_portals_by_id**](AuthenticationPortalsApi.md#delete_authentication_portals_by_id) | **DELETE** /authentication-portals/{id} | Delete an authentication portal
+[**get_authentication_portals_by_id**](AuthenticationPortalsApi.md#get_authentication_portals_by_id) | **GET** /authentication-portals/{id} | Get an authentication portal
+[**list_authentication_portals**](AuthenticationPortalsApi.md#list_authentication_portals) | **GET** /authentication-portals | List authentication portals
+[**update_authentication_portals_by_id**](AuthenticationPortalsApi.md#update_authentication_portals_by_id) | **PUT** /authentication-portals/{id} | Update an authentication portal
+
+
+# **create_authentication_portals**
+> AuthenticationPortals create_authentication_portals(authentication_portals=authentication_portals)
+
+Create an authentication portal
+
+Create a new authentication portal.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationPortalsApi(api_client)
+ authentication_portals = scm.identity_services.AuthenticationPortals() # AuthenticationPortals | Created (optional)
+
+ try:
+ # Create an authentication portal
+ api_response = api_instance.create_authentication_portals(authentication_portals=authentication_portals)
+ print("The response of AuthenticationPortalsApi->create_authentication_portals:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationPortalsApi->create_authentication_portals: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **authentication_portals** | [**AuthenticationPortals**](AuthenticationPortals.md)| Created | [optional]
+
+### Return type
+
+[**AuthenticationPortals**](AuthenticationPortals.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_authentication_portals_by_id**
+> delete_authentication_portals_by_id(id)
+
+Delete an authentication portal
+
+Delete an authentication portal.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationPortalsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an authentication portal
+ api_instance.delete_authentication_portals_by_id(id)
+ except Exception as e:
+ print("Exception when calling AuthenticationPortalsApi->delete_authentication_portals_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_authentication_portals_by_id**
+> AuthenticationPortals get_authentication_portals_by_id(id)
+
+Get an authentication portal
+
+Get an existing authentication portal.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationPortalsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get an authentication portal
+ api_response = api_instance.get_authentication_portals_by_id(id)
+ print("The response of AuthenticationPortalsApi->get_authentication_portals_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationPortalsApi->get_authentication_portals_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**AuthenticationPortals**](AuthenticationPortals.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_authentication_portals**
+> AuthenticationPortalsListResponse list_authentication_portals(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List authentication portals
+
+Retreive a list of authentication portals.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_portals_list_response import AuthenticationPortalsListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationPortalsApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List authentication portals
+ api_response = api_instance.list_authentication_portals(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of AuthenticationPortalsApi->list_authentication_portals:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationPortalsApi->list_authentication_portals: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**AuthenticationPortalsListResponse**](AuthenticationPortalsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_authentication_portals_by_id**
+> AuthenticationPortals update_authentication_portals_by_id(id, authentication_portals=authentication_portals)
+
+Update an authentication portal
+
+Update an existing authentication portal.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationPortalsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ authentication_portals = scm.identity_services.AuthenticationPortals() # AuthenticationPortals | OK (optional)
+
+ try:
+ # Update an authentication portal
+ api_response = api_instance.update_authentication_portals_by_id(id, authentication_portals=authentication_portals)
+ print("The response of AuthenticationPortalsApi->update_authentication_portals_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationPortalsApi->update_authentication_portals_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **authentication_portals** | [**AuthenticationPortals**](AuthenticationPortals.md)| OK | [optional]
+
+### Return type
+
+[**AuthenticationPortals**](AuthenticationPortals.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/AuthenticationPortalsListResponse.md b/scm/identity_services/docs/AuthenticationPortalsListResponse.md
new file mode 100644
index 00000000..72e96a31
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationPortalsListResponse.md
@@ -0,0 +1,32 @@
+# AuthenticationPortalsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[AuthenticationPortals]**](AuthenticationPortals.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_portals_list_response import AuthenticationPortalsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationPortalsListResponse from a JSON string
+authentication_portals_list_response_instance = AuthenticationPortalsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationPortalsListResponse.to_json())
+
+# convert the object into a dict
+authentication_portals_list_response_dict = authentication_portals_list_response_instance.to_dict()
+# create an instance of AuthenticationPortalsListResponse from a dict
+authentication_portals_list_response_from_dict = AuthenticationPortalsListResponse.from_dict(authentication_portals_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfiles.md b/scm/identity_services/docs/AuthenticationProfiles.md
new file mode 100644
index 00000000..ff329aba
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfiles.md
@@ -0,0 +1,40 @@
+# AuthenticationProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**allow_list** | **List[str]** | The allow_list of the authentication profile | [optional] [default to ["all"]]
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the authentication profile | [optional] [readonly]
+**lockout** | [**AuthenticationProfilesLockout**](AuthenticationProfilesLockout.md) | | [optional]
+**method** | [**AuthenticationProfilesMethod**](AuthenticationProfilesMethod.md) | | [optional]
+**multi_factor_auth** | [**AuthenticationProfilesMultiFactorAuth**](AuthenticationProfilesMultiFactorAuth.md) | | [optional]
+**name** | **str** | The name of the authentication profile |
+**single_sign_on** | [**AuthenticationProfilesSingleSignOn**](AuthenticationProfilesSingleSignOn.md) | | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**user_domain** | **str** | | [optional]
+**username_modifier** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfiles from a JSON string
+authentication_profiles_instance = AuthenticationProfiles.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfiles.to_json())
+
+# convert the object into a dict
+authentication_profiles_dict = authentication_profiles_instance.to_dict()
+# create an instance of AuthenticationProfiles from a dict
+authentication_profiles_from_dict = AuthenticationProfiles.from_dict(authentication_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesApi.md b/scm/identity_services/docs/AuthenticationProfilesApi.md
new file mode 100644
index 00000000..9a855a68
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.AuthenticationProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_authentication_profiles**](AuthenticationProfilesApi.md#create_authentication_profiles) | **POST** /authentication-profiles | Create an authentication profile
+[**delete_authentication_profiles_by_id**](AuthenticationProfilesApi.md#delete_authentication_profiles_by_id) | **DELETE** /authentication-profiles/{id} | Delete an authentication profile
+[**get_authentication_profiles_by_id**](AuthenticationProfilesApi.md#get_authentication_profiles_by_id) | **GET** /authentication-profiles/{id} | Get an authentication profile
+[**list_authentication_profiles**](AuthenticationProfilesApi.md#list_authentication_profiles) | **GET** /authentication-profiles | List authentication profiles
+[**update_authentication_profiles_by_id**](AuthenticationProfilesApi.md#update_authentication_profiles_by_id) | **PUT** /authentication-profiles/{id} | Update an authentication profile
+
+
+# **create_authentication_profiles**
+> AuthenticationProfiles create_authentication_profiles(authentication_profiles=authentication_profiles)
+
+Create an authentication profile
+
+Create an authentication profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationProfilesApi(api_client)
+ authentication_profiles = scm.identity_services.AuthenticationProfiles() # AuthenticationProfiles | Created (optional)
+
+ try:
+ # Create an authentication profile
+ api_response = api_instance.create_authentication_profiles(authentication_profiles=authentication_profiles)
+ print("The response of AuthenticationProfilesApi->create_authentication_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationProfilesApi->create_authentication_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **authentication_profiles** | [**AuthenticationProfiles**](AuthenticationProfiles.md)| Created | [optional]
+
+### Return type
+
+[**AuthenticationProfiles**](AuthenticationProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_authentication_profiles_by_id**
+> delete_authentication_profiles_by_id(id)
+
+Delete an authentication profile
+
+Delete an authentication profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an authentication profile
+ api_instance.delete_authentication_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling AuthenticationProfilesApi->delete_authentication_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_authentication_profiles_by_id**
+> AuthenticationProfiles get_authentication_profiles_by_id(id)
+
+Get an authentication profile
+
+Get an existing authentication profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get an authentication profile
+ api_response = api_instance.get_authentication_profiles_by_id(id)
+ print("The response of AuthenticationProfilesApi->get_authentication_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationProfilesApi->get_authentication_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**AuthenticationProfiles**](AuthenticationProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_authentication_profiles**
+> AuthenticationProfilesListResponse list_authentication_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List authentication profiles
+
+Retrieve a list of authentication profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_profiles_list_response import AuthenticationProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List authentication profiles
+ api_response = api_instance.list_authentication_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of AuthenticationProfilesApi->list_authentication_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationProfilesApi->list_authentication_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**AuthenticationProfilesListResponse**](AuthenticationProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_authentication_profiles_by_id**
+> AuthenticationProfiles update_authentication_profiles_by_id(id, authentication_profiles=authentication_profiles)
+
+Update an authentication profile
+
+Update an existing authentication profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ authentication_profiles = scm.identity_services.AuthenticationProfiles() # AuthenticationProfiles | OK (optional)
+
+ try:
+ # Update an authentication profile
+ api_response = api_instance.update_authentication_profiles_by_id(id, authentication_profiles=authentication_profiles)
+ print("The response of AuthenticationProfilesApi->update_authentication_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationProfilesApi->update_authentication_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **authentication_profiles** | [**AuthenticationProfiles**](AuthenticationProfiles.md)| OK | [optional]
+
+### Return type
+
+[**AuthenticationProfiles**](AuthenticationProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesListResponse.md b/scm/identity_services/docs/AuthenticationProfilesListResponse.md
new file mode 100644
index 00000000..c151279d
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesListResponse.md
@@ -0,0 +1,32 @@
+# AuthenticationProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[AuthenticationProfiles]**](AuthenticationProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_list_response import AuthenticationProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesListResponse from a JSON string
+authentication_profiles_list_response_instance = AuthenticationProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesListResponse.to_json())
+
+# convert the object into a dict
+authentication_profiles_list_response_dict = authentication_profiles_list_response_instance.to_dict()
+# create an instance of AuthenticationProfilesListResponse from a dict
+authentication_profiles_list_response_from_dict = AuthenticationProfilesListResponse.from_dict(authentication_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesLockout.md b/scm/identity_services/docs/AuthenticationProfilesLockout.md
new file mode 100644
index 00000000..d2e7c251
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesLockout.md
@@ -0,0 +1,31 @@
+# AuthenticationProfilesLockout
+
+Lockout object of the authentication profile
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**failed_attempts** | **int** | Lockout object - failed_attempts of authentication profile | [optional]
+**lockout_time** | **int** | Lockout object - lockout-time of authentication profile | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_lockout import AuthenticationProfilesLockout
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesLockout from a JSON string
+authentication_profiles_lockout_instance = AuthenticationProfilesLockout.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesLockout.to_json())
+
+# convert the object into a dict
+authentication_profiles_lockout_dict = authentication_profiles_lockout_instance.to_dict()
+# create an instance of AuthenticationProfilesLockout from a dict
+authentication_profiles_lockout_from_dict = AuthenticationProfilesLockout.from_dict(authentication_profiles_lockout_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMethod.md b/scm/identity_services/docs/AuthenticationProfilesMethod.md
new file mode 100644
index 00000000..d499629c
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMethod.md
@@ -0,0 +1,36 @@
+# AuthenticationProfilesMethod
+
+method object of authentication profile
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**cloud** | [**AuthenticationProfilesMethodCloud**](AuthenticationProfilesMethodCloud.md) | | [optional]
+**kerberos** | [**AuthenticationProfilesMethodKerberos**](AuthenticationProfilesMethodKerberos.md) | | [optional]
+**ldap** | [**AuthenticationProfilesMethodLdap**](AuthenticationProfilesMethodLdap.md) | | [optional]
+**local_database** | **object** | | [optional]
+**radius** | [**AuthenticationProfilesMethodRadius**](AuthenticationProfilesMethodRadius.md) | | [optional]
+**saml_idp** | [**AuthenticationProfilesMethodSamlIdp**](AuthenticationProfilesMethodSamlIdp.md) | | [optional]
+**tacplus** | [**AuthenticationProfilesMethodTacplus**](AuthenticationProfilesMethodTacplus.md) | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMethod from a JSON string
+authentication_profiles_method_instance = AuthenticationProfilesMethod.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMethod.to_json())
+
+# convert the object into a dict
+authentication_profiles_method_dict = authentication_profiles_method_instance.to_dict()
+# create an instance of AuthenticationProfilesMethod from a dict
+authentication_profiles_method_from_dict = AuthenticationProfilesMethod.from_dict(authentication_profiles_method_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMethodCloud.md b/scm/identity_services/docs/AuthenticationProfilesMethodCloud.md
new file mode 100644
index 00000000..9ec560f6
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMethodCloud.md
@@ -0,0 +1,29 @@
+# AuthenticationProfilesMethodCloud
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**profile_name** | **str** | The tenant profile name | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_method_cloud import AuthenticationProfilesMethodCloud
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMethodCloud from a JSON string
+authentication_profiles_method_cloud_instance = AuthenticationProfilesMethodCloud.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMethodCloud.to_json())
+
+# convert the object into a dict
+authentication_profiles_method_cloud_dict = authentication_profiles_method_cloud_instance.to_dict()
+# create an instance of AuthenticationProfilesMethodCloud from a dict
+authentication_profiles_method_cloud_from_dict = AuthenticationProfilesMethodCloud.from_dict(authentication_profiles_method_cloud_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMethodKerberos.md b/scm/identity_services/docs/AuthenticationProfilesMethodKerberos.md
new file mode 100644
index 00000000..2eab8500
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMethodKerberos.md
@@ -0,0 +1,30 @@
+# AuthenticationProfilesMethodKerberos
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**realm** | **str** | method kerberos object realm of authentication profile | [optional]
+**server_profile** | **str** | method kerberos object server profile of authentication profile | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_method_kerberos import AuthenticationProfilesMethodKerberos
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMethodKerberos from a JSON string
+authentication_profiles_method_kerberos_instance = AuthenticationProfilesMethodKerberos.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMethodKerberos.to_json())
+
+# convert the object into a dict
+authentication_profiles_method_kerberos_dict = authentication_profiles_method_kerberos_instance.to_dict()
+# create an instance of AuthenticationProfilesMethodKerberos from a dict
+authentication_profiles_method_kerberos_from_dict = AuthenticationProfilesMethodKerberos.from_dict(authentication_profiles_method_kerberos_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMethodLdap.md b/scm/identity_services/docs/AuthenticationProfilesMethodLdap.md
new file mode 100644
index 00000000..7b9e7236
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMethodLdap.md
@@ -0,0 +1,31 @@
+# AuthenticationProfilesMethodLdap
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**login_attribute** | **str** | | [optional]
+**passwd_exp_days** | **int** | | [optional]
+**server_profile** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_method_ldap import AuthenticationProfilesMethodLdap
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMethodLdap from a JSON string
+authentication_profiles_method_ldap_instance = AuthenticationProfilesMethodLdap.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMethodLdap.to_json())
+
+# convert the object into a dict
+authentication_profiles_method_ldap_dict = authentication_profiles_method_ldap_instance.to_dict()
+# create an instance of AuthenticationProfilesMethodLdap from a dict
+authentication_profiles_method_ldap_from_dict = AuthenticationProfilesMethodLdap.from_dict(authentication_profiles_method_ldap_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMethodRadius.md b/scm/identity_services/docs/AuthenticationProfilesMethodRadius.md
new file mode 100644
index 00000000..0b445cf0
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMethodRadius.md
@@ -0,0 +1,30 @@
+# AuthenticationProfilesMethodRadius
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**checkgroup** | **bool** | method radius object check group of authentication profile | [optional]
+**server_profile** | **str** | method radius object server profile of authentication profile | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_method_radius import AuthenticationProfilesMethodRadius
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMethodRadius from a JSON string
+authentication_profiles_method_radius_instance = AuthenticationProfilesMethodRadius.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMethodRadius.to_json())
+
+# convert the object into a dict
+authentication_profiles_method_radius_dict = authentication_profiles_method_radius_instance.to_dict()
+# create an instance of AuthenticationProfilesMethodRadius from a dict
+authentication_profiles_method_radius_from_dict = AuthenticationProfilesMethodRadius.from_dict(authentication_profiles_method_radius_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMethodSamlIdp.md b/scm/identity_services/docs/AuthenticationProfilesMethodSamlIdp.md
new file mode 100644
index 00000000..277a31a0
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMethodSamlIdp.md
@@ -0,0 +1,34 @@
+# AuthenticationProfilesMethodSamlIdp
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**attribute_name_usergroup** | **str** | | [optional]
+**attribute_name_username** | **str** | | [optional]
+**certificate_profile** | **str** | method object saml idp certificate profile of authentication profile | [optional]
+**enable_single_logout** | **bool** | | [optional]
+**request_signing_certificate** | **str** | | [optional]
+**server_profile** | **str** | method object saml idp server profile of authentication profile | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_method_saml_idp import AuthenticationProfilesMethodSamlIdp
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMethodSamlIdp from a JSON string
+authentication_profiles_method_saml_idp_instance = AuthenticationProfilesMethodSamlIdp.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMethodSamlIdp.to_json())
+
+# convert the object into a dict
+authentication_profiles_method_saml_idp_dict = authentication_profiles_method_saml_idp_instance.to_dict()
+# create an instance of AuthenticationProfilesMethodSamlIdp from a dict
+authentication_profiles_method_saml_idp_from_dict = AuthenticationProfilesMethodSamlIdp.from_dict(authentication_profiles_method_saml_idp_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMethodTacplus.md b/scm/identity_services/docs/AuthenticationProfilesMethodTacplus.md
new file mode 100644
index 00000000..87c8dbd0
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMethodTacplus.md
@@ -0,0 +1,30 @@
+# AuthenticationProfilesMethodTacplus
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**checkgroup** | **bool** | method tacplus object check group of authentication profile | [optional]
+**server_profile** | **str** | method tacplus object check group of authentication profile | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_method_tacplus import AuthenticationProfilesMethodTacplus
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMethodTacplus from a JSON string
+authentication_profiles_method_tacplus_instance = AuthenticationProfilesMethodTacplus.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMethodTacplus.to_json())
+
+# convert the object into a dict
+authentication_profiles_method_tacplus_dict = authentication_profiles_method_tacplus_instance.to_dict()
+# create an instance of AuthenticationProfilesMethodTacplus from a dict
+authentication_profiles_method_tacplus_from_dict = AuthenticationProfilesMethodTacplus.from_dict(authentication_profiles_method_tacplus_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesMultiFactorAuth.md b/scm/identity_services/docs/AuthenticationProfilesMultiFactorAuth.md
new file mode 100644
index 00000000..836d5f4b
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesMultiFactorAuth.md
@@ -0,0 +1,30 @@
+# AuthenticationProfilesMultiFactorAuth
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**factors** | **List[str]** | | [optional]
+**mfa_enable** | **bool** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_multi_factor_auth import AuthenticationProfilesMultiFactorAuth
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesMultiFactorAuth from a JSON string
+authentication_profiles_multi_factor_auth_instance = AuthenticationProfilesMultiFactorAuth.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesMultiFactorAuth.to_json())
+
+# convert the object into a dict
+authentication_profiles_multi_factor_auth_dict = authentication_profiles_multi_factor_auth_instance.to_dict()
+# create an instance of AuthenticationProfilesMultiFactorAuth from a dict
+authentication_profiles_multi_factor_auth_from_dict = AuthenticationProfilesMultiFactorAuth.from_dict(authentication_profiles_multi_factor_auth_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationProfilesSingleSignOn.md b/scm/identity_services/docs/AuthenticationProfilesSingleSignOn.md
new file mode 100644
index 00000000..5ecdd676
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationProfilesSingleSignOn.md
@@ -0,0 +1,30 @@
+# AuthenticationProfilesSingleSignOn
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**kerberos_keytab** | **str** | | [optional]
+**realm** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_profiles_single_sign_on import AuthenticationProfilesSingleSignOn
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationProfilesSingleSignOn from a JSON string
+authentication_profiles_single_sign_on_instance = AuthenticationProfilesSingleSignOn.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationProfilesSingleSignOn.to_json())
+
+# convert the object into a dict
+authentication_profiles_single_sign_on_dict = authentication_profiles_single_sign_on_instance.to_dict()
+# create an instance of AuthenticationProfilesSingleSignOn from a dict
+authentication_profiles_single_sign_on_from_dict = AuthenticationProfilesSingleSignOn.from_dict(authentication_profiles_single_sign_on_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationRules.md b/scm/identity_services/docs/AuthenticationRules.md
new file mode 100644
index 00000000..0d81bba6
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationRules.md
@@ -0,0 +1,53 @@
+# AuthenticationRules
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authentication_enforcement** | **str** | The authentication profile name | [optional]
+**category** | **List[str]** | The destination URL categories | [optional]
+**description** | **str** | The description of the authentication rule | [optional]
+**destination** | **List[str]** | The destination addresses |
+**destination_hip** | **List[str]** | The destination Host Integrity Profile (HIP) | [optional]
+**device** | **str** | | [optional]
+**disabled** | **bool** | Is the authentication rule disabled? | [optional] [default to False]
+**folder** | **str** | | [optional]
+**var_from** | **List[str]** | The source security zones |
+**group_tag** | **str** | | [optional]
+**hip_profiles** | **List[str]** | The source Host Integrity Profile (HIP) | [optional]
+**id** | **str** | The UUID of the authentication rule | [optional] [readonly]
+**log_authentication_timeout** | **bool** | Log authentication timeouts? | [optional] [default to False]
+**log_setting** | **str** | The log forwarding profile name | [optional]
+**name** | **str** | The name of the authentication rule |
+**negate_destination** | **bool** | Are the destination addresses negated? | [optional] [default to False]
+**negate_source** | **bool** | Are the source addresses negated? | [optional] [default to False]
+**service** | **List[str]** | The destination ports |
+**snippet** | **str** | | [optional]
+**source** | **List[str]** | The source addresses |
+**source_hip** | **List[str]** | The source Host Integrity Profile (HIP) | [optional]
+**source_user** | **List[str]** | The source users | [optional]
+**tag** | **List[str]** | The authentication rule tags | [optional]
+**timeout** | **int** | The authentication session timeout (seconds) | [optional]
+**to** | **List[str]** | The destination security zones |
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationRules from a JSON string
+authentication_rules_instance = AuthenticationRules.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationRules.to_json())
+
+# convert the object into a dict
+authentication_rules_dict = authentication_rules_instance.to_dict()
+# create an instance of AuthenticationRules from a dict
+authentication_rules_from_dict = AuthenticationRules.from_dict(authentication_rules_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationRulesApi.md b/scm/identity_services/docs/AuthenticationRulesApi.md
new file mode 100644
index 00000000..f2d362a2
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationRulesApi.md
@@ -0,0 +1,527 @@
+# scm.identity_services.AuthenticationRulesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_authentication_rules**](AuthenticationRulesApi.md#create_authentication_rules) | **POST** /authentication-rules | Create an authentication rule
+[**delete_authentication_rules_by_id**](AuthenticationRulesApi.md#delete_authentication_rules_by_id) | **DELETE** /authentication-rules/{id} | Delete an authentication rule
+[**get_authentication_rules_by_id**](AuthenticationRulesApi.md#get_authentication_rules_by_id) | **GET** /authentication-rules/{id} | Get an authentication rule
+[**list_authentication_rules**](AuthenticationRulesApi.md#list_authentication_rules) | **GET** /authentication-rules | List authentication rules
+[**move_authentication_rules_by_id**](AuthenticationRulesApi.md#move_authentication_rules_by_id) | **POST** /authentication-rules/{id}:move | Move an authentication rule
+[**update_authentication_rules_by_id**](AuthenticationRulesApi.md#update_authentication_rules_by_id) | **PUT** /authentication-rules/{id} | Update an authentication rule
+
+
+# **create_authentication_rules**
+> AuthenticationRules create_authentication_rules(position, authentication_rules=authentication_rules)
+
+Create an authentication rule
+
+Create a new authentication rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationRulesApi(api_client)
+ position = pre # str | The relative position of the rule (default to pre)
+ authentication_rules = scm.identity_services.AuthenticationRules() # AuthenticationRules | Created (optional)
+
+ try:
+ # Create an authentication rule
+ api_response = api_instance.create_authentication_rules(position, authentication_rules=authentication_rules)
+ print("The response of AuthenticationRulesApi->create_authentication_rules:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationRulesApi->create_authentication_rules: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **position** | **str**| The relative position of the rule | [default to pre]
+ **authentication_rules** | [**AuthenticationRules**](AuthenticationRules.md)| Created | [optional]
+
+### Return type
+
+[**AuthenticationRules**](AuthenticationRules.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_authentication_rules_by_id**
+> delete_authentication_rules_by_id(id)
+
+Delete an authentication rule
+
+Delete an authentication rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationRulesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an authentication rule
+ api_instance.delete_authentication_rules_by_id(id)
+ except Exception as e:
+ print("Exception when calling AuthenticationRulesApi->delete_authentication_rules_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_authentication_rules_by_id**
+> AuthenticationRules get_authentication_rules_by_id(id)
+
+Get an authentication rule
+
+Get an existing authentication rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationRulesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get an authentication rule
+ api_response = api_instance.get_authentication_rules_by_id(id)
+ print("The response of AuthenticationRulesApi->get_authentication_rules_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationRulesApi->get_authentication_rules_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**AuthenticationRules**](AuthenticationRules.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_authentication_rules**
+> AuthenticationRulesListResponse list_authentication_rules(position, name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List authentication rules
+
+Retrieve a list of authentication rules.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_rules_list_response import AuthenticationRulesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationRulesApi(api_client)
+ position = pre # str | The relative position of the rule (default to pre)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List authentication rules
+ api_response = api_instance.list_authentication_rules(position, name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of AuthenticationRulesApi->list_authentication_rules:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationRulesApi->list_authentication_rules: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **position** | **str**| The relative position of the rule | [default to pre]
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**AuthenticationRulesListResponse**](AuthenticationRulesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **move_authentication_rules_by_id**
+> move_authentication_rules_by_id(id, rule_based_move=rule_based_move)
+
+Move an authentication rule
+
+Move an existing authentication rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.rule_based_move import RuleBasedMove
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationRulesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ rule_based_move = scm.identity_services.RuleBasedMove() # RuleBasedMove | OK (optional)
+
+ try:
+ # Move an authentication rule
+ api_instance.move_authentication_rules_by_id(id, rule_based_move=rule_based_move)
+ except Exception as e:
+ print("Exception when calling AuthenticationRulesApi->move_authentication_rules_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **rule_based_move** | [**RuleBasedMove**](RuleBasedMove.md)| OK | [optional]
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_authentication_rules_by_id**
+> AuthenticationRules update_authentication_rules_by_id(id, authentication_rules=authentication_rules)
+
+Update an authentication rule
+
+Update an existing authentication rule.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationRulesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ authentication_rules = scm.identity_services.AuthenticationRules() # AuthenticationRules | OK (optional)
+
+ try:
+ # Update an authentication rule
+ api_response = api_instance.update_authentication_rules_by_id(id, authentication_rules=authentication_rules)
+ print("The response of AuthenticationRulesApi->update_authentication_rules_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationRulesApi->update_authentication_rules_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **authentication_rules** | [**AuthenticationRules**](AuthenticationRules.md)| OK | [optional]
+
+### Return type
+
+[**AuthenticationRules**](AuthenticationRules.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/AuthenticationRulesListResponse.md b/scm/identity_services/docs/AuthenticationRulesListResponse.md
new file mode 100644
index 00000000..891ee859
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationRulesListResponse.md
@@ -0,0 +1,32 @@
+# AuthenticationRulesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[AuthenticationRules]**](AuthenticationRules.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_rules_list_response import AuthenticationRulesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationRulesListResponse from a JSON string
+authentication_rules_list_response_instance = AuthenticationRulesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationRulesListResponse.to_json())
+
+# convert the object into a dict
+authentication_rules_list_response_dict = authentication_rules_list_response_instance.to_dict()
+# create an instance of AuthenticationRulesListResponse from a dict
+authentication_rules_list_response_from_dict = AuthenticationRulesListResponse.from_dict(authentication_rules_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationSequences.md b/scm/identity_services/docs/AuthenticationSequences.md
new file mode 100644
index 00000000..262ad0f6
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationSequences.md
@@ -0,0 +1,35 @@
+# AuthenticationSequences
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**authentication_profiles** | **List[str]** | An ordered list of authentication profiles | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the authentication sequence | [optional] [readonly]
+**name** | **str** | The name of the authentication sequence |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**use_domain_find_profile** | **bool** | Use domain to determine authentication profile? | [optional] [default to True]
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationSequences from a JSON string
+authentication_sequences_instance = AuthenticationSequences.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationSequences.to_json())
+
+# convert the object into a dict
+authentication_sequences_dict = authentication_sequences_instance.to_dict()
+# create an instance of AuthenticationSequences from a dict
+authentication_sequences_from_dict = AuthenticationSequences.from_dict(authentication_sequences_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/AuthenticationSequencesApi.md b/scm/identity_services/docs/AuthenticationSequencesApi.md
new file mode 100644
index 00000000..75062c6b
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationSequencesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.AuthenticationSequencesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_authentication_sequences**](AuthenticationSequencesApi.md#create_authentication_sequences) | **POST** /authentication-sequences | Create an authentication sequence
+[**delete_authentication_sequences_by_id**](AuthenticationSequencesApi.md#delete_authentication_sequences_by_id) | **DELETE** /authentication-sequences/{id} | Delete an authentication sequence
+[**get_authentication_sequences_by_id**](AuthenticationSequencesApi.md#get_authentication_sequences_by_id) | **GET** /authentication-sequences/{id} | Get an authentication sequence
+[**list_authentication_sequences**](AuthenticationSequencesApi.md#list_authentication_sequences) | **GET** /authentication-sequences | List authentication sequences
+[**update_authentication_sequences_by_id**](AuthenticationSequencesApi.md#update_authentication_sequences_by_id) | **PUT** /authentication-sequences/{id} | Update an authentication sequence
+
+
+# **create_authentication_sequences**
+> AuthenticationSequences create_authentication_sequences(authentication_sequences=authentication_sequences)
+
+Create an authentication sequence
+
+Create a new authentication sequence.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationSequencesApi(api_client)
+ authentication_sequences = scm.identity_services.AuthenticationSequences() # AuthenticationSequences | Created (optional)
+
+ try:
+ # Create an authentication sequence
+ api_response = api_instance.create_authentication_sequences(authentication_sequences=authentication_sequences)
+ print("The response of AuthenticationSequencesApi->create_authentication_sequences:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSequencesApi->create_authentication_sequences: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **authentication_sequences** | [**AuthenticationSequences**](AuthenticationSequences.md)| Created | [optional]
+
+### Return type
+
+[**AuthenticationSequences**](AuthenticationSequences.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_authentication_sequences_by_id**
+> delete_authentication_sequences_by_id(id)
+
+Delete an authentication sequence
+
+Delete an authentication sequence.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationSequencesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an authentication sequence
+ api_instance.delete_authentication_sequences_by_id(id)
+ except Exception as e:
+ print("Exception when calling AuthenticationSequencesApi->delete_authentication_sequences_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_authentication_sequences_by_id**
+> AuthenticationSequences get_authentication_sequences_by_id(id)
+
+Get an authentication sequence
+
+Get an existing authentication sequence.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationSequencesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get an authentication sequence
+ api_response = api_instance.get_authentication_sequences_by_id(id)
+ print("The response of AuthenticationSequencesApi->get_authentication_sequences_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSequencesApi->get_authentication_sequences_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**AuthenticationSequences**](AuthenticationSequences.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_authentication_sequences**
+> AuthenticationSequencesListResponse list_authentication_sequences(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List authentication sequences
+
+Retrieve a list of authentication sequences.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_sequences_list_response import AuthenticationSequencesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationSequencesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List authentication sequences
+ api_response = api_instance.list_authentication_sequences(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of AuthenticationSequencesApi->list_authentication_sequences:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSequencesApi->list_authentication_sequences: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**AuthenticationSequencesListResponse**](AuthenticationSequencesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_authentication_sequences_by_id**
+> AuthenticationSequences update_authentication_sequences_by_id(id, authentication_sequences=authentication_sequences)
+
+Update an authentication sequence
+
+Update an existing authentication sequence.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.AuthenticationSequencesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ authentication_sequences = scm.identity_services.AuthenticationSequences() # AuthenticationSequences | OK (optional)
+
+ try:
+ # Update an authentication sequence
+ api_response = api_instance.update_authentication_sequences_by_id(id, authentication_sequences=authentication_sequences)
+ print("The response of AuthenticationSequencesApi->update_authentication_sequences_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling AuthenticationSequencesApi->update_authentication_sequences_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **authentication_sequences** | [**AuthenticationSequences**](AuthenticationSequences.md)| OK | [optional]
+
+### Return type
+
+[**AuthenticationSequences**](AuthenticationSequences.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/AuthenticationSequencesListResponse.md b/scm/identity_services/docs/AuthenticationSequencesListResponse.md
new file mode 100644
index 00000000..ed8cb1ca
--- /dev/null
+++ b/scm/identity_services/docs/AuthenticationSequencesListResponse.md
@@ -0,0 +1,32 @@
+# AuthenticationSequencesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[AuthenticationSequences]**](AuthenticationSequences.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.authentication_sequences_list_response import AuthenticationSequencesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of AuthenticationSequencesListResponse from a JSON string
+authentication_sequences_list_response_instance = AuthenticationSequencesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(AuthenticationSequencesListResponse.to_json())
+
+# convert the object into a dict
+authentication_sequences_list_response_dict = authentication_sequences_list_response_instance.to_dict()
+# create an instance of AuthenticationSequencesListResponse from a dict
+authentication_sequences_list_response_from_dict = AuthenticationSequencesListResponse.from_dict(authentication_sequences_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificateProfiles.md b/scm/identity_services/docs/CertificateProfiles.md
new file mode 100644
index 00000000..cde26a8f
--- /dev/null
+++ b/scm/identity_services/docs/CertificateProfiles.md
@@ -0,0 +1,45 @@
+# CertificateProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**block_expired_cert** | **bool** | Block sessions with expired certificates? | [optional]
+**block_timeout_cert** | **bool** | Block session if certificate status cannot be retrieved within timeout? | [optional]
+**block_unauthenticated_cert** | **bool** | Block session if the certificate was not issued to the authenticating device? | [optional]
+**block_unknown_cert** | **bool** | Block session if certificate status is unknown? | [optional]
+**ca_certificates** | [**List[CertificateProfilesCaCertificatesInner]**](CertificateProfilesCaCertificatesInner.md) | An ordered list of CA certificates |
+**cert_status_timeout** | **str** | Certificate status timeout | [optional]
+**crl_receive_timeout** | **str** | CRL receive timeout (seconds) | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**domain** | **str** | User domain | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the certificate profile | [optional] [readonly]
+**name** | **str** | The name of the certificate profile |
+**ocsp_receive_timeout** | **str** | OCSP receive timeout (seconds) | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**use_crl** | **bool** | Use CRL? | [optional]
+**use_ocsp** | **bool** | Use OCSP? | [optional]
+**username_field** | [**CertificateProfilesUsernameField**](CertificateProfilesUsernameField.md) | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificateProfiles from a JSON string
+certificate_profiles_instance = CertificateProfiles.from_json(json)
+# print the JSON string representation of the object
+print(CertificateProfiles.to_json())
+
+# convert the object into a dict
+certificate_profiles_dict = certificate_profiles_instance.to_dict()
+# create an instance of CertificateProfiles from a dict
+certificate_profiles_from_dict = CertificateProfiles.from_dict(certificate_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificateProfilesApi.md b/scm/identity_services/docs/CertificateProfilesApi.md
new file mode 100644
index 00000000..ddda8ee1
--- /dev/null
+++ b/scm/identity_services/docs/CertificateProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.CertificateProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_certificate_profiles**](CertificateProfilesApi.md#create_certificate_profiles) | **POST** /certificate-profiles | Create a certificate profile
+[**delete_certificate_profiles_by_id**](CertificateProfilesApi.md#delete_certificate_profiles_by_id) | **DELETE** /certificate-profiles/{id} | Delete a certificate profile
+[**get_certificate_profiles_by_id**](CertificateProfilesApi.md#get_certificate_profiles_by_id) | **GET** /certificate-profiles/{id} | Get a certificate profile
+[**list_certificate_profiles**](CertificateProfilesApi.md#list_certificate_profiles) | **GET** /certificate-profiles | List certificate profiles
+[**update_certificate_profiles_by_id**](CertificateProfilesApi.md#update_certificate_profiles_by_id) | **PUT** /certificate-profiles/{id} | Update a certificate profile
+
+
+# **create_certificate_profiles**
+> CertificateProfiles create_certificate_profiles(certificate_profiles=certificate_profiles)
+
+Create a certificate profile
+
+Create a certificate profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificateProfilesApi(api_client)
+ certificate_profiles = scm.identity_services.CertificateProfiles() # CertificateProfiles | Created (optional)
+
+ try:
+ # Create a certificate profile
+ api_response = api_instance.create_certificate_profiles(certificate_profiles=certificate_profiles)
+ print("The response of CertificateProfilesApi->create_certificate_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificateProfilesApi->create_certificate_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **certificate_profiles** | [**CertificateProfiles**](CertificateProfiles.md)| Created | [optional]
+
+### Return type
+
+[**CertificateProfiles**](CertificateProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_certificate_profiles_by_id**
+> delete_certificate_profiles_by_id(id)
+
+Delete a certificate profile
+
+Delete a certificate profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificateProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a certificate profile
+ api_instance.delete_certificate_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling CertificateProfilesApi->delete_certificate_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_certificate_profiles_by_id**
+> CertificateProfiles get_certificate_profiles_by_id(id)
+
+Get a certificate profile
+
+Get an existing certificate profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificateProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a certificate profile
+ api_response = api_instance.get_certificate_profiles_by_id(id)
+ print("The response of CertificateProfilesApi->get_certificate_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificateProfilesApi->get_certificate_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**CertificateProfiles**](CertificateProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_certificate_profiles**
+> CertificateProfilesListResponse list_certificate_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List certificate profiles
+
+Retrieve a list of certificate profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.certificate_profiles_list_response import CertificateProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificateProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List certificate profiles
+ api_response = api_instance.list_certificate_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of CertificateProfilesApi->list_certificate_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificateProfilesApi->list_certificate_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**CertificateProfilesListResponse**](CertificateProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_certificate_profiles_by_id**
+> CertificateProfiles update_certificate_profiles_by_id(id, certificate_profiles=certificate_profiles)
+
+Update a certificate profile
+
+Update an existing certificate profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificateProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ certificate_profiles = scm.identity_services.CertificateProfiles() # CertificateProfiles | OK (optional)
+
+ try:
+ # Update a certificate profile
+ api_response = api_instance.update_certificate_profiles_by_id(id, certificate_profiles=certificate_profiles)
+ print("The response of CertificateProfilesApi->update_certificate_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificateProfilesApi->update_certificate_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **certificate_profiles** | [**CertificateProfiles**](CertificateProfiles.md)| OK | [optional]
+
+### Return type
+
+[**CertificateProfiles**](CertificateProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/CertificateProfilesCaCertificatesInner.md b/scm/identity_services/docs/CertificateProfilesCaCertificatesInner.md
new file mode 100644
index 00000000..01242308
--- /dev/null
+++ b/scm/identity_services/docs/CertificateProfilesCaCertificatesInner.md
@@ -0,0 +1,33 @@
+# CertificateProfilesCaCertificatesInner
+
+CA certificate
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**default_ocsp_url** | **str** | Default OCSP URL | [optional]
+**name** | **str** | CA certificate name |
+**ocsp_verify_cert** | **str** | OCSP verify certificate | [optional]
+**template_name** | **str** | Template name/OID | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.certificate_profiles_ca_certificates_inner import CertificateProfilesCaCertificatesInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificateProfilesCaCertificatesInner from a JSON string
+certificate_profiles_ca_certificates_inner_instance = CertificateProfilesCaCertificatesInner.from_json(json)
+# print the JSON string representation of the object
+print(CertificateProfilesCaCertificatesInner.to_json())
+
+# convert the object into a dict
+certificate_profiles_ca_certificates_inner_dict = certificate_profiles_ca_certificates_inner_instance.to_dict()
+# create an instance of CertificateProfilesCaCertificatesInner from a dict
+certificate_profiles_ca_certificates_inner_from_dict = CertificateProfilesCaCertificatesInner.from_dict(certificate_profiles_ca_certificates_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificateProfilesListResponse.md b/scm/identity_services/docs/CertificateProfilesListResponse.md
new file mode 100644
index 00000000..0c737b4f
--- /dev/null
+++ b/scm/identity_services/docs/CertificateProfilesListResponse.md
@@ -0,0 +1,32 @@
+# CertificateProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[CertificateProfiles]**](CertificateProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.certificate_profiles_list_response import CertificateProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificateProfilesListResponse from a JSON string
+certificate_profiles_list_response_instance = CertificateProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(CertificateProfilesListResponse.to_json())
+
+# convert the object into a dict
+certificate_profiles_list_response_dict = certificate_profiles_list_response_instance.to_dict()
+# create an instance of CertificateProfilesListResponse from a dict
+certificate_profiles_list_response_from_dict = CertificateProfilesListResponse.from_dict(certificate_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificateProfilesUsernameField.md b/scm/identity_services/docs/CertificateProfilesUsernameField.md
new file mode 100644
index 00000000..e907d1da
--- /dev/null
+++ b/scm/identity_services/docs/CertificateProfilesUsernameField.md
@@ -0,0 +1,31 @@
+# CertificateProfilesUsernameField
+
+Certificate username field
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**subject** | **str** | Common name | [optional]
+**subject_alt** | **str** | Email address | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.certificate_profiles_username_field import CertificateProfilesUsernameField
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificateProfilesUsernameField from a JSON string
+certificate_profiles_username_field_instance = CertificateProfilesUsernameField.from_json(json)
+# print the JSON string representation of the object
+print(CertificateProfilesUsernameField.to_json())
+
+# convert the object into a dict
+certificate_profiles_username_field_dict = certificate_profiles_username_field_instance.to_dict()
+# create an instance of CertificateProfilesUsernameField from a dict
+certificate_profiles_username_field_from_dict = CertificateProfilesUsernameField.from_dict(certificate_profiles_username_field_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificatesApi.md b/scm/identity_services/docs/CertificatesApi.md
new file mode 100644
index 00000000..e5b49c87
--- /dev/null
+++ b/scm/identity_services/docs/CertificatesApi.md
@@ -0,0 +1,441 @@
+# scm.identity_services.CertificatesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_certificates**](CertificatesApi.md#create_certificates) | **POST** /certificates | Generate a certificate
+[**delete_certificates_by_id**](CertificatesApi.md#delete_certificates_by_id) | **DELETE** /certificates/{id} | Delete a certificate
+[**export_certificate_by_id**](CertificatesApi.md#export_certificate_by_id) | **POST** /certificates/{id}:export | Export a certificate
+[**get_certificates_by_id**](CertificatesApi.md#get_certificates_by_id) | **GET** /certificates/{id} | Get a certificate
+[**list_certificates**](CertificatesApi.md#list_certificates) | **GET** /certificates | List certificates
+
+
+# **create_certificates**
+> CertificatesGet create_certificates(certificates_post=certificates_post)
+
+Generate a certificate
+
+Generate a new certificate.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.certificates_get import CertificatesGet
+from scm.identity_services.models.certificates_post import CertificatesPost
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificatesApi(api_client)
+ certificates_post = scm.identity_services.CertificatesPost() # CertificatesPost | Created (optional)
+
+ try:
+ # Generate a certificate
+ api_response = api_instance.create_certificates(certificates_post=certificates_post)
+ print("The response of CertificatesApi->create_certificates:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificatesApi->create_certificates: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **certificates_post** | [**CertificatesPost**](CertificatesPost.md)| Created | [optional]
+
+### Return type
+
+[**CertificatesGet**](CertificatesGet.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_certificates_by_id**
+> delete_certificates_by_id(id)
+
+Delete a certificate
+
+Delete a certificate.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificatesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a certificate
+ api_instance.delete_certificates_by_id(id)
+ except Exception as e:
+ print("Exception when calling CertificatesApi->delete_certificates_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **export_certificate_by_id**
+> ExportCertificateResponse export_certificate_by_id(id, export_certificate_payload=export_certificate_payload)
+
+Export a certificate
+
+Export a certificate.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.export_certificate_payload import ExportCertificatePayload
+from scm.identity_services.models.export_certificate_response import ExportCertificateResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificatesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ export_certificate_payload = scm.identity_services.ExportCertificatePayload() # ExportCertificatePayload | Export a Certificate (optional)
+
+ try:
+ # Export a certificate
+ api_response = api_instance.export_certificate_by_id(id, export_certificate_payload=export_certificate_payload)
+ print("The response of CertificatesApi->export_certificate_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificatesApi->export_certificate_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **export_certificate_payload** | [**ExportCertificatePayload**](ExportCertificatePayload.md)| Export a Certificate | [optional]
+
+### Return type
+
+[**ExportCertificateResponse**](ExportCertificateResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_certificates_by_id**
+> CertificatesGet get_certificates_by_id(id)
+
+Get a certificate
+
+Get an existing certificate.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.certificates_get import CertificatesGet
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificatesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a certificate
+ api_response = api_instance.get_certificates_by_id(id)
+ print("The response of CertificatesApi->get_certificates_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificatesApi->get_certificates_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**CertificatesGet**](CertificatesGet.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_certificates**
+> CertificatesListResponse list_certificates(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List certificates
+
+Retrieve a list of certificates.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.certificates_list_response import CertificatesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.CertificatesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List certificates
+ api_response = api_instance.list_certificates(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of CertificatesApi->list_certificates:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling CertificatesApi->list_certificates: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**CertificatesListResponse**](CertificatesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/CertificatesGet.md b/scm/identity_services/docs/CertificatesGet.md
new file mode 100644
index 00000000..6af791d1
--- /dev/null
+++ b/scm/identity_services/docs/CertificatesGet.md
@@ -0,0 +1,46 @@
+# CertificatesGet
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**algorithm** | **str** | Algorithm | [optional]
+**ca** | **bool** | CA certificate? | [optional]
+**common_name** | **str** | Common name | [optional]
+**common_name_int** | **str** | | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**expiry_epoch** | **str** | | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the certificate | [optional] [readonly]
+**issuer** | **str** | Issuer | [optional]
+**issuer_hash** | **str** | Issue hash | [optional]
+**name** | **str** | The name of the certificate | [optional]
+**not_valid_after** | **date** | Not valid after this date | [optional]
+**not_valid_before** | **date** | Not valid before this date | [optional]
+**public_key** | **str** | Public key | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**subject** | **str** | Subject | [optional]
+**subject_hash** | **str** | Subject hash | [optional]
+**subject_int** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.certificates_get import CertificatesGet
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificatesGet from a JSON string
+certificates_get_instance = CertificatesGet.from_json(json)
+# print the JSON string representation of the object
+print(CertificatesGet.to_json())
+
+# convert the object into a dict
+certificates_get_dict = certificates_get_instance.to_dict()
+# create an instance of CertificatesGet from a dict
+certificates_get_from_dict = CertificatesGet.from_dict(certificates_get_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificatesImport.md b/scm/identity_services/docs/CertificatesImport.md
new file mode 100644
index 00000000..041008f2
--- /dev/null
+++ b/scm/identity_services/docs/CertificatesImport.md
@@ -0,0 +1,36 @@
+# CertificatesImport
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**certificate_file** | **str** | The Base64 encoded content of the certificate public key |
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**format** | **str** | Certificate format | [default to 'pem']
+**key_file** | **str** | The Base64 encoded content of the certificate private key | [optional]
+**name** | **str** | The name of the certificate |
+**passphrase** | **str** | Passphrase to protect the certificate private key | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.certificates_import import CertificatesImport
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificatesImport from a JSON string
+certificates_import_instance = CertificatesImport.from_json(json)
+# print the JSON string representation of the object
+print(CertificatesImport.to_json())
+
+# convert the object into a dict
+certificates_import_dict = certificates_import_instance.to_dict()
+# create an instance of CertificatesImport from a dict
+certificates_import_from_dict = CertificatesImport.from_dict(certificates_import_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificatesListResponse.md b/scm/identity_services/docs/CertificatesListResponse.md
new file mode 100644
index 00000000..ed2ba13d
--- /dev/null
+++ b/scm/identity_services/docs/CertificatesListResponse.md
@@ -0,0 +1,32 @@
+# CertificatesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[CertificatesGet]**](CertificatesGet.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.certificates_list_response import CertificatesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificatesListResponse from a JSON string
+certificates_list_response_instance = CertificatesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(CertificatesListResponse.to_json())
+
+# convert the object into a dict
+certificates_list_response_dict = certificates_list_response_instance.to_dict()
+# create an instance of CertificatesListResponse from a dict
+certificates_list_response_from_dict = CertificatesListResponse.from_dict(certificates_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificatesPost.md b/scm/identity_services/docs/CertificatesPost.md
new file mode 100644
index 00000000..2b761b92
--- /dev/null
+++ b/scm/identity_services/docs/CertificatesPost.md
@@ -0,0 +1,48 @@
+# CertificatesPost
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**algorithm** | [**CertificatesPostAlgorithm**](CertificatesPostAlgorithm.md) | |
+**alternate_email** | **List[str]** | Alternate email | [optional]
+**certificate_name** | **str** | Certificate name |
+**common_name** | **str** | Common name |
+**country_code** | **str** | Country code | [optional]
+**day_till_expiration** | **int** | Expiration (days) | [optional]
+**department** | **List[str]** | Department | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**digest** | **str** | Hash algorithm |
+**email** | **str** | Email | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**hostname** | **List[str]** | Hostname | [optional]
+**ip** | **List[str]** | IP address | [optional]
+**is_block_private_key** | **bool** | Block private key export? | [optional]
+**is_certificate_authority** | **bool** | Certificate authority certificate? | [optional]
+**locality** | **str** | Locality | [optional]
+**ocsp_responder_url** | **str** | OCSP responder URL | [optional]
+**signed_by** | **str** | Signed by |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**state** | **str** | State | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.certificates_post import CertificatesPost
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificatesPost from a JSON string
+certificates_post_instance = CertificatesPost.from_json(json)
+# print the JSON string representation of the object
+print(CertificatesPost.to_json())
+
+# convert the object into a dict
+certificates_post_dict = certificates_post_instance.to_dict()
+# create an instance of CertificatesPost from a dict
+certificates_post_from_dict = CertificatesPost.from_dict(certificates_post_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/CertificatesPostAlgorithm.md b/scm/identity_services/docs/CertificatesPostAlgorithm.md
new file mode 100644
index 00000000..9bda615d
--- /dev/null
+++ b/scm/identity_services/docs/CertificatesPostAlgorithm.md
@@ -0,0 +1,31 @@
+# CertificatesPostAlgorithm
+
+Encryption algorithm
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ecdsa_number_of_bits** | **float** | | [optional]
+**rsa_number_of_bits** | **float** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.certificates_post_algorithm import CertificatesPostAlgorithm
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of CertificatesPostAlgorithm from a JSON string
+certificates_post_algorithm_instance = CertificatesPostAlgorithm.from_json(json)
+# print the JSON string representation of the object
+print(CertificatesPostAlgorithm.to_json())
+
+# convert the object into a dict
+certificates_post_algorithm_dict = certificates_post_algorithm_instance.to_dict()
+# create an instance of CertificatesPostAlgorithm from a dict
+certificates_post_algorithm_from_dict = CertificatesPostAlgorithm.from_dict(certificates_post_algorithm_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ErrorDetailCauseInfo.md b/scm/identity_services/docs/ErrorDetailCauseInfo.md
new file mode 100644
index 00000000..e024dec8
--- /dev/null
+++ b/scm/identity_services/docs/ErrorDetailCauseInfo.md
@@ -0,0 +1,32 @@
+# ErrorDetailCauseInfo
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**code** | **str** | | [optional]
+**details** | **object** | | [optional]
+**help** | **str** | | [optional]
+**message** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ErrorDetailCauseInfo from a JSON string
+error_detail_cause_info_instance = ErrorDetailCauseInfo.from_json(json)
+# print the JSON string representation of the object
+print(ErrorDetailCauseInfo.to_json())
+
+# convert the object into a dict
+error_detail_cause_info_dict = error_detail_cause_info_instance.to_dict()
+# create an instance of ErrorDetailCauseInfo from a dict
+error_detail_cause_info_from_dict = ErrorDetailCauseInfo.from_dict(error_detail_cause_info_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ExportCertificatePayload.md b/scm/identity_services/docs/ExportCertificatePayload.md
new file mode 100644
index 00000000..6d1f546b
--- /dev/null
+++ b/scm/identity_services/docs/ExportCertificatePayload.md
@@ -0,0 +1,30 @@
+# ExportCertificatePayload
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**format** | **str** | |
+**passphrase** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.export_certificate_payload import ExportCertificatePayload
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ExportCertificatePayload from a JSON string
+export_certificate_payload_instance = ExportCertificatePayload.from_json(json)
+# print the JSON string representation of the object
+print(ExportCertificatePayload.to_json())
+
+# convert the object into a dict
+export_certificate_payload_dict = export_certificate_payload_instance.to_dict()
+# create an instance of ExportCertificatePayload from a dict
+export_certificate_payload_from_dict = ExportCertificatePayload.from_dict(export_certificate_payload_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ExportCertificateResponse.md b/scm/identity_services/docs/ExportCertificateResponse.md
new file mode 100644
index 00000000..dea588bc
--- /dev/null
+++ b/scm/identity_services/docs/ExportCertificateResponse.md
@@ -0,0 +1,29 @@
+# ExportCertificateResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**certificate** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.export_certificate_response import ExportCertificateResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ExportCertificateResponse from a JSON string
+export_certificate_response_instance = ExportCertificateResponse.from_json(json)
+# print the JSON string representation of the object
+print(ExportCertificateResponse.to_json())
+
+# convert the object into a dict
+export_certificate_response_dict = export_certificate_response_instance.to_dict()
+# create an instance of ExportCertificateResponse from a dict
+export_certificate_response_from_dict = ExportCertificateResponse.from_dict(export_certificate_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/GenericError.md b/scm/identity_services/docs/GenericError.md
new file mode 100644
index 00000000..c0413ed1
--- /dev/null
+++ b/scm/identity_services/docs/GenericError.md
@@ -0,0 +1,30 @@
+# GenericError
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**errors** | [**List[ErrorDetailCauseInfo]**](ErrorDetailCauseInfo.md) | | [optional]
+**request_id** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.generic_error import GenericError
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of GenericError from a JSON string
+generic_error_instance = GenericError.from_json(json)
+# print the JSON string representation of the object
+print(GenericError.to_json())
+
+# convert the object into a dict
+generic_error_dict = generic_error_instance.to_dict()
+# create an instance of GenericError from a dict
+generic_error_from_dict = GenericError.from_dict(generic_error_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/KerberosServerProfiles.md b/scm/identity_services/docs/KerberosServerProfiles.md
new file mode 100644
index 00000000..838e0412
--- /dev/null
+++ b/scm/identity_services/docs/KerberosServerProfiles.md
@@ -0,0 +1,34 @@
+# KerberosServerProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the Kerberos server profile | [readonly]
+**name** | **str** | The name of the Kerberos server profile |
+**server** | [**List[KerberosServerProfilesServerInner]**](KerberosServerProfilesServerInner.md) | The Kerberos server configuration |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of KerberosServerProfiles from a JSON string
+kerberos_server_profiles_instance = KerberosServerProfiles.from_json(json)
+# print the JSON string representation of the object
+print(KerberosServerProfiles.to_json())
+
+# convert the object into a dict
+kerberos_server_profiles_dict = kerberos_server_profiles_instance.to_dict()
+# create an instance of KerberosServerProfiles from a dict
+kerberos_server_profiles_from_dict = KerberosServerProfiles.from_dict(kerberos_server_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/KerberosServerProfilesApi.md b/scm/identity_services/docs/KerberosServerProfilesApi.md
new file mode 100644
index 00000000..4aed1c0a
--- /dev/null
+++ b/scm/identity_services/docs/KerberosServerProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.KerberosServerProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_kerberos_server_profiles**](KerberosServerProfilesApi.md#create_kerberos_server_profiles) | **POST** /kerberos-server-profiles | Create a Kerberos server profile
+[**delete_kerberos_server_profiles_by_id**](KerberosServerProfilesApi.md#delete_kerberos_server_profiles_by_id) | **DELETE** /kerberos-server-profiles/{id} | Delete a Kerberos server profile
+[**get_kerberos_server_profiles_by_id**](KerberosServerProfilesApi.md#get_kerberos_server_profiles_by_id) | **GET** /kerberos-server-profiles/{id} | Get a Kerberos server profile
+[**list_kerberos_server_profiles**](KerberosServerProfilesApi.md#list_kerberos_server_profiles) | **GET** /kerberos-server-profiles | List Kerberos server profiles
+[**update_kerberos_server_profiles_by_id**](KerberosServerProfilesApi.md#update_kerberos_server_profiles_by_id) | **PUT** /kerberos-server-profiles/{id} | Update a Kerberos server profile
+
+
+# **create_kerberos_server_profiles**
+> KerberosServerProfiles create_kerberos_server_profiles(kerberos_server_profiles=kerberos_server_profiles)
+
+Create a Kerberos server profile
+
+Create a new Kerberos server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.KerberosServerProfilesApi(api_client)
+ kerberos_server_profiles = scm.identity_services.KerberosServerProfiles() # KerberosServerProfiles | Created (optional)
+
+ try:
+ # Create a Kerberos server profile
+ api_response = api_instance.create_kerberos_server_profiles(kerberos_server_profiles=kerberos_server_profiles)
+ print("The response of KerberosServerProfilesApi->create_kerberos_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling KerberosServerProfilesApi->create_kerberos_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **kerberos_server_profiles** | [**KerberosServerProfiles**](KerberosServerProfiles.md)| Created | [optional]
+
+### Return type
+
+[**KerberosServerProfiles**](KerberosServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_kerberos_server_profiles_by_id**
+> delete_kerberos_server_profiles_by_id(id)
+
+Delete a Kerberos server profile
+
+Delete a Kerberos server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.KerberosServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a Kerberos server profile
+ api_instance.delete_kerberos_server_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling KerberosServerProfilesApi->delete_kerberos_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_kerberos_server_profiles_by_id**
+> KerberosServerProfiles get_kerberos_server_profiles_by_id(id)
+
+Get a Kerberos server profile
+
+Get an existing Kerberos server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.KerberosServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a Kerberos server profile
+ api_response = api_instance.get_kerberos_server_profiles_by_id(id)
+ print("The response of KerberosServerProfilesApi->get_kerberos_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling KerberosServerProfilesApi->get_kerberos_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**KerberosServerProfiles**](KerberosServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_kerberos_server_profiles**
+> KerberosServerProfilesListResponse list_kerberos_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List Kerberos server profiles
+
+Retrieve a list of Kerberos server profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.kerberos_server_profiles_list_response import KerberosServerProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.KerberosServerProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List Kerberos server profiles
+ api_response = api_instance.list_kerberos_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of KerberosServerProfilesApi->list_kerberos_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling KerberosServerProfilesApi->list_kerberos_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**KerberosServerProfilesListResponse**](KerberosServerProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_kerberos_server_profiles_by_id**
+> KerberosServerProfiles update_kerberos_server_profiles_by_id(id, kerberos_server_profiles=kerberos_server_profiles)
+
+Update a Kerberos server profile
+
+Update an existing Kerberos server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.KerberosServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ kerberos_server_profiles = scm.identity_services.KerberosServerProfiles() # KerberosServerProfiles | OK (optional)
+
+ try:
+ # Update a Kerberos server profile
+ api_response = api_instance.update_kerberos_server_profiles_by_id(id, kerberos_server_profiles=kerberos_server_profiles)
+ print("The response of KerberosServerProfilesApi->update_kerberos_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling KerberosServerProfilesApi->update_kerberos_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **kerberos_server_profiles** | [**KerberosServerProfiles**](KerberosServerProfiles.md)| OK | [optional]
+
+### Return type
+
+[**KerberosServerProfiles**](KerberosServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/KerberosServerProfilesListResponse.md b/scm/identity_services/docs/KerberosServerProfilesListResponse.md
new file mode 100644
index 00000000..56f92871
--- /dev/null
+++ b/scm/identity_services/docs/KerberosServerProfilesListResponse.md
@@ -0,0 +1,32 @@
+# KerberosServerProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[KerberosServerProfiles]**](KerberosServerProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.kerberos_server_profiles_list_response import KerberosServerProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of KerberosServerProfilesListResponse from a JSON string
+kerberos_server_profiles_list_response_instance = KerberosServerProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(KerberosServerProfilesListResponse.to_json())
+
+# convert the object into a dict
+kerberos_server_profiles_list_response_dict = kerberos_server_profiles_list_response_instance.to_dict()
+# create an instance of KerberosServerProfilesListResponse from a dict
+kerberos_server_profiles_list_response_from_dict = KerberosServerProfilesListResponse.from_dict(kerberos_server_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/KerberosServerProfilesServerInner.md b/scm/identity_services/docs/KerberosServerProfilesServerInner.md
new file mode 100644
index 00000000..3c9cdffc
--- /dev/null
+++ b/scm/identity_services/docs/KerberosServerProfilesServerInner.md
@@ -0,0 +1,31 @@
+# KerberosServerProfilesServerInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**host** | **str** | The Kerberos server IP address |
+**name** | **str** | The Kerberos server name |
+**port** | **int** | The Kerberos server port | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.kerberos_server_profiles_server_inner import KerberosServerProfilesServerInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of KerberosServerProfilesServerInner from a JSON string
+kerberos_server_profiles_server_inner_instance = KerberosServerProfilesServerInner.from_json(json)
+# print the JSON string representation of the object
+print(KerberosServerProfilesServerInner.to_json())
+
+# convert the object into a dict
+kerberos_server_profiles_server_inner_dict = kerberos_server_profiles_server_inner_instance.to_dict()
+# create an instance of KerberosServerProfilesServerInner from a dict
+kerberos_server_profiles_server_inner_from_dict = KerberosServerProfilesServerInner.from_dict(kerberos_server_profiles_server_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/LDAPServerProfilesApi.md b/scm/identity_services/docs/LDAPServerProfilesApi.md
new file mode 100644
index 00000000..a238073f
--- /dev/null
+++ b/scm/identity_services/docs/LDAPServerProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.LDAPServerProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_ldap_server_profiles**](LDAPServerProfilesApi.md#create_ldap_server_profiles) | **POST** /ldap-server-profiles | Create an LDAP server profile
+[**delete_ldap_server_profiles_by_id**](LDAPServerProfilesApi.md#delete_ldap_server_profiles_by_id) | **DELETE** /ldap-server-profiles/{id} | Delete an LDAP server profile
+[**get_ldap_server_profiles_by_id**](LDAPServerProfilesApi.md#get_ldap_server_profiles_by_id) | **GET** /ldap-server-profiles/{id} | Get an LDAP server profile
+[**list_ldap_server_profiles**](LDAPServerProfilesApi.md#list_ldap_server_profiles) | **GET** /ldap-server-profiles | List LDAP server profiles
+[**update_ldap_server_profiles**](LDAPServerProfilesApi.md#update_ldap_server_profiles) | **PUT** /ldap-server-profiles/{id} | Update an LDAP server profile
+
+
+# **create_ldap_server_profiles**
+> LdapServerProfiles create_ldap_server_profiles(ldap_server_profiles=ldap_server_profiles)
+
+Create an LDAP server profile
+
+Create a new LDAP server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LDAPServerProfilesApi(api_client)
+ ldap_server_profiles = scm.identity_services.LdapServerProfiles() # LdapServerProfiles | Created (optional)
+
+ try:
+ # Create an LDAP server profile
+ api_response = api_instance.create_ldap_server_profiles(ldap_server_profiles=ldap_server_profiles)
+ print("The response of LDAPServerProfilesApi->create_ldap_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LDAPServerProfilesApi->create_ldap_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **ldap_server_profiles** | [**LdapServerProfiles**](LdapServerProfiles.md)| Created | [optional]
+
+### Return type
+
+[**LdapServerProfiles**](LdapServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_ldap_server_profiles_by_id**
+> delete_ldap_server_profiles_by_id(id)
+
+Delete an LDAP server profile
+
+Delete a LDAP server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LDAPServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an LDAP server profile
+ api_instance.delete_ldap_server_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling LDAPServerProfilesApi->delete_ldap_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_ldap_server_profiles_by_id**
+> LdapServerProfiles get_ldap_server_profiles_by_id(id)
+
+Get an LDAP server profile
+
+Get an existing LDAP server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LDAPServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get an LDAP server profile
+ api_response = api_instance.get_ldap_server_profiles_by_id(id)
+ print("The response of LDAPServerProfilesApi->get_ldap_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LDAPServerProfilesApi->get_ldap_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**LdapServerProfiles**](LdapServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_ldap_server_profiles**
+> LDAPServerProfilesListResponse list_ldap_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List LDAP server profiles
+
+Retrieve a list of LDAP server profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ldap_server_profiles_list_response import LDAPServerProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LDAPServerProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List LDAP server profiles
+ api_response = api_instance.list_ldap_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of LDAPServerProfilesApi->list_ldap_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LDAPServerProfilesApi->list_ldap_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**LDAPServerProfilesListResponse**](LDAPServerProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_ldap_server_profiles**
+> LdapServerProfiles update_ldap_server_profiles(id, ldap_server_profiles=ldap_server_profiles)
+
+Update an LDAP server profile
+
+Update an existing LDAP server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LDAPServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ ldap_server_profiles = scm.identity_services.LdapServerProfiles() # LdapServerProfiles | OK (optional)
+
+ try:
+ # Update an LDAP server profile
+ api_response = api_instance.update_ldap_server_profiles(id, ldap_server_profiles=ldap_server_profiles)
+ print("The response of LDAPServerProfilesApi->update_ldap_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LDAPServerProfilesApi->update_ldap_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **ldap_server_profiles** | [**LdapServerProfiles**](LdapServerProfiles.md)| OK | [optional]
+
+### Return type
+
+[**LdapServerProfiles**](LdapServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/LDAPServerProfilesListResponse.md b/scm/identity_services/docs/LDAPServerProfilesListResponse.md
new file mode 100644
index 00000000..84315b02
--- /dev/null
+++ b/scm/identity_services/docs/LDAPServerProfilesListResponse.md
@@ -0,0 +1,32 @@
+# LDAPServerProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[LdapServerProfiles]**](LdapServerProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.ldap_server_profiles_list_response import LDAPServerProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LDAPServerProfilesListResponse from a JSON string
+ldap_server_profiles_list_response_instance = LDAPServerProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(LDAPServerProfilesListResponse.to_json())
+
+# convert the object into a dict
+ldap_server_profiles_list_response_dict = ldap_server_profiles_list_response_instance.to_dict()
+# create an instance of LDAPServerProfilesListResponse from a dict
+ldap_server_profiles_list_response_from_dict = LDAPServerProfilesListResponse.from_dict(ldap_server_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/LdapServerProfiles.md b/scm/identity_services/docs/LdapServerProfiles.md
new file mode 100644
index 00000000..9afc025a
--- /dev/null
+++ b/scm/identity_services/docs/LdapServerProfiles.md
@@ -0,0 +1,43 @@
+# LdapServerProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**base** | **str** | The base DN | [optional]
+**bind_dn** | **str** | The bind DN | [optional]
+**bind_password** | **str** | The bind password | [optional]
+**bind_timelimit** | **str** | The bind timeout (seconds) | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the LDAP server profile | [readonly]
+**ldap_type** | **str** | The LDAP server time | [optional]
+**name** | **str** | The name of the LDAP server profile |
+**retry_interval** | **int** | The search retry interval (seconds) | [optional]
+**server** | [**List[LdapServerProfilesServerInner]**](LdapServerProfilesServerInner.md) | The LDAP server configuration |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**ssl** | **bool** | Require SSL/TLS secured connection? | [optional]
+**timelimit** | **int** | The search timeout (seconds) | [optional]
+**verify_server_certificate** | **bool** | Verify server certificate for SSL sessions? | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LdapServerProfiles from a JSON string
+ldap_server_profiles_instance = LdapServerProfiles.from_json(json)
+# print the JSON string representation of the object
+print(LdapServerProfiles.to_json())
+
+# convert the object into a dict
+ldap_server_profiles_dict = ldap_server_profiles_instance.to_dict()
+# create an instance of LdapServerProfiles from a dict
+ldap_server_profiles_from_dict = LdapServerProfiles.from_dict(ldap_server_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/LdapServerProfilesServerInner.md b/scm/identity_services/docs/LdapServerProfilesServerInner.md
new file mode 100644
index 00000000..f03aa088
--- /dev/null
+++ b/scm/identity_services/docs/LdapServerProfilesServerInner.md
@@ -0,0 +1,31 @@
+# LdapServerProfilesServerInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**address** | **str** | The LDAP server IP address | [optional]
+**name** | **str** | The LDAP server name | [optional]
+**port** | **int** | The LDAP server port | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.ldap_server_profiles_server_inner import LdapServerProfilesServerInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LdapServerProfilesServerInner from a JSON string
+ldap_server_profiles_server_inner_instance = LdapServerProfilesServerInner.from_json(json)
+# print the JSON string representation of the object
+print(LdapServerProfilesServerInner.to_json())
+
+# convert the object into a dict
+ldap_server_profiles_server_inner_dict = ldap_server_profiles_server_inner_instance.to_dict()
+# create an instance of LdapServerProfilesServerInner from a dict
+ldap_server_profiles_server_inner_from_dict = LdapServerProfilesServerInner.from_dict(ldap_server_profiles_server_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/LocalUserGroups.md b/scm/identity_services/docs/LocalUserGroups.md
new file mode 100644
index 00000000..d67f0650
--- /dev/null
+++ b/scm/identity_services/docs/LocalUserGroups.md
@@ -0,0 +1,34 @@
+# LocalUserGroups
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the local user group | [readonly]
+**name** | **str** | The name of the local user group |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**user** | **List[str]** | The local user group users | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LocalUserGroups from a JSON string
+local_user_groups_instance = LocalUserGroups.from_json(json)
+# print the JSON string representation of the object
+print(LocalUserGroups.to_json())
+
+# convert the object into a dict
+local_user_groups_dict = local_user_groups_instance.to_dict()
+# create an instance of LocalUserGroups from a dict
+local_user_groups_from_dict = LocalUserGroups.from_dict(local_user_groups_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/LocalUserGroupsApi.md b/scm/identity_services/docs/LocalUserGroupsApi.md
new file mode 100644
index 00000000..a5ee0c7b
--- /dev/null
+++ b/scm/identity_services/docs/LocalUserGroupsApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.LocalUserGroupsApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_local_user_groups**](LocalUserGroupsApi.md#create_local_user_groups) | **POST** /local-user-groups | Create a local user group
+[**delete_local_user_groups_by_id**](LocalUserGroupsApi.md#delete_local_user_groups_by_id) | **DELETE** /local-user-groups/{id} | Delete a local user group
+[**get_local_user_groups_by_id**](LocalUserGroupsApi.md#get_local_user_groups_by_id) | **GET** /local-user-groups/{id} | Get a local user group
+[**list_local_user_groups**](LocalUserGroupsApi.md#list_local_user_groups) | **GET** /local-user-groups | List local user groups
+[**update_local_user_groups_by_id**](LocalUserGroupsApi.md#update_local_user_groups_by_id) | **PUT** /local-user-groups/{id} | Update a local user group
+
+
+# **create_local_user_groups**
+> LocalUserGroups create_local_user_groups(local_user_groups=local_user_groups)
+
+Create a local user group
+
+Create a new local user group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUserGroupsApi(api_client)
+ local_user_groups = scm.identity_services.LocalUserGroups() # LocalUserGroups | Created (optional)
+
+ try:
+ # Create a local user group
+ api_response = api_instance.create_local_user_groups(local_user_groups=local_user_groups)
+ print("The response of LocalUserGroupsApi->create_local_user_groups:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUserGroupsApi->create_local_user_groups: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **local_user_groups** | [**LocalUserGroups**](LocalUserGroups.md)| Created | [optional]
+
+### Return type
+
+[**LocalUserGroups**](LocalUserGroups.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_local_user_groups_by_id**
+> delete_local_user_groups_by_id(id)
+
+Delete a local user group
+
+Delete a local user group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUserGroupsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a local user group
+ api_instance.delete_local_user_groups_by_id(id)
+ except Exception as e:
+ print("Exception when calling LocalUserGroupsApi->delete_local_user_groups_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_local_user_groups_by_id**
+> LocalUserGroups get_local_user_groups_by_id(id)
+
+Get a local user group
+
+Get an existing local user group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUserGroupsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a local user group
+ api_response = api_instance.get_local_user_groups_by_id(id)
+ print("The response of LocalUserGroupsApi->get_local_user_groups_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUserGroupsApi->get_local_user_groups_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**LocalUserGroups**](LocalUserGroups.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_local_user_groups**
+> LocalUserGroupsListResponse list_local_user_groups(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List local user groups
+
+Retrieve a list of local user groups.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_user_groups_list_response import LocalUserGroupsListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUserGroupsApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List local user groups
+ api_response = api_instance.list_local_user_groups(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of LocalUserGroupsApi->list_local_user_groups:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUserGroupsApi->list_local_user_groups: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**LocalUserGroupsListResponse**](LocalUserGroupsListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_local_user_groups_by_id**
+> LocalUserGroups update_local_user_groups_by_id(id, local_user_groups=local_user_groups)
+
+Update a local user group
+
+Update an existing local user group.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUserGroupsApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ local_user_groups = scm.identity_services.LocalUserGroups() # LocalUserGroups | OK (optional)
+
+ try:
+ # Update a local user group
+ api_response = api_instance.update_local_user_groups_by_id(id, local_user_groups=local_user_groups)
+ print("The response of LocalUserGroupsApi->update_local_user_groups_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUserGroupsApi->update_local_user_groups_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **local_user_groups** | [**LocalUserGroups**](LocalUserGroups.md)| OK | [optional]
+
+### Return type
+
+[**LocalUserGroups**](LocalUserGroups.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/LocalUserGroupsListResponse.md b/scm/identity_services/docs/LocalUserGroupsListResponse.md
new file mode 100644
index 00000000..80eb9442
--- /dev/null
+++ b/scm/identity_services/docs/LocalUserGroupsListResponse.md
@@ -0,0 +1,32 @@
+# LocalUserGroupsListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[LocalUserGroups]**](LocalUserGroups.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.local_user_groups_list_response import LocalUserGroupsListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LocalUserGroupsListResponse from a JSON string
+local_user_groups_list_response_instance = LocalUserGroupsListResponse.from_json(json)
+# print the JSON string representation of the object
+print(LocalUserGroupsListResponse.to_json())
+
+# convert the object into a dict
+local_user_groups_list_response_dict = local_user_groups_list_response_instance.to_dict()
+# create an instance of LocalUserGroupsListResponse from a dict
+local_user_groups_list_response_from_dict = LocalUserGroupsListResponse.from_dict(local_user_groups_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/LocalUsers.md b/scm/identity_services/docs/LocalUsers.md
new file mode 100644
index 00000000..2d8dda6a
--- /dev/null
+++ b/scm/identity_services/docs/LocalUsers.md
@@ -0,0 +1,35 @@
+# LocalUsers
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**disabled** | **bool** | Is the local user disabled? | [optional] [default to False]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the local user | [readonly]
+**name** | **str** | The name of the local user |
+**password** | **str** | The password of the local user |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.local_users import LocalUsers
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LocalUsers from a JSON string
+local_users_instance = LocalUsers.from_json(json)
+# print the JSON string representation of the object
+print(LocalUsers.to_json())
+
+# convert the object into a dict
+local_users_dict = local_users_instance.to_dict()
+# create an instance of LocalUsers from a dict
+local_users_from_dict = LocalUsers.from_dict(local_users_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/LocalUsersApi.md b/scm/identity_services/docs/LocalUsersApi.md
new file mode 100644
index 00000000..f3c0c0b5
--- /dev/null
+++ b/scm/identity_services/docs/LocalUsersApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.LocalUsersApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_local_users**](LocalUsersApi.md#create_local_users) | **POST** /local-users | Create a local user
+[**delete_local_users_by_id**](LocalUsersApi.md#delete_local_users_by_id) | **DELETE** /local-users/{id} | Delete a local user
+[**get_local_users_by_id**](LocalUsersApi.md#get_local_users_by_id) | **GET** /local-users/{id} | Get a local user
+[**list_local_users**](LocalUsersApi.md#list_local_users) | **GET** /local-users | List local users
+[**update_local_users_by_id**](LocalUsersApi.md#update_local_users_by_id) | **PUT** /local-users/{id} | Update a local user
+
+
+# **create_local_users**
+> LocalUsers create_local_users(local_users=local_users)
+
+Create a local user
+
+Create a new local user.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_users import LocalUsers
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUsersApi(api_client)
+ local_users = scm.identity_services.LocalUsers() # LocalUsers | Created (optional)
+
+ try:
+ # Create a local user
+ api_response = api_instance.create_local_users(local_users=local_users)
+ print("The response of LocalUsersApi->create_local_users:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUsersApi->create_local_users: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **local_users** | [**LocalUsers**](LocalUsers.md)| Created | [optional]
+
+### Return type
+
+[**LocalUsers**](LocalUsers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_local_users_by_id**
+> delete_local_users_by_id(id)
+
+Delete a local user
+
+Delete a local user.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUsersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a local user
+ api_instance.delete_local_users_by_id(id)
+ except Exception as e:
+ print("Exception when calling LocalUsersApi->delete_local_users_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_local_users_by_id**
+> LocalUsers get_local_users_by_id(id)
+
+Get a local user
+
+Get an existing local user.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_users import LocalUsers
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUsersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a local user
+ api_response = api_instance.get_local_users_by_id(id)
+ print("The response of LocalUsersApi->get_local_users_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUsersApi->get_local_users_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**LocalUsers**](LocalUsers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_local_users**
+> LocalUsersListResponse list_local_users(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List local users
+
+Retrieve a list of local users.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_users_list_response import LocalUsersListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUsersApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List local users
+ api_response = api_instance.list_local_users(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of LocalUsersApi->list_local_users:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUsersApi->list_local_users: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**LocalUsersListResponse**](LocalUsersListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_local_users_by_id**
+> LocalUsers update_local_users_by_id(id, local_users=local_users)
+
+Update a local user
+
+Update an existing local user.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.local_users import LocalUsers
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.LocalUsersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ local_users = scm.identity_services.LocalUsers() # LocalUsers | OK (optional)
+
+ try:
+ # Update a local user
+ api_response = api_instance.update_local_users_by_id(id, local_users=local_users)
+ print("The response of LocalUsersApi->update_local_users_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling LocalUsersApi->update_local_users_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **local_users** | [**LocalUsers**](LocalUsers.md)| OK | [optional]
+
+### Return type
+
+[**LocalUsers**](LocalUsers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/LocalUsersListResponse.md b/scm/identity_services/docs/LocalUsersListResponse.md
new file mode 100644
index 00000000..78496362
--- /dev/null
+++ b/scm/identity_services/docs/LocalUsersListResponse.md
@@ -0,0 +1,32 @@
+# LocalUsersListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[LocalUsers]**](LocalUsers.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.local_users_list_response import LocalUsersListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of LocalUsersListResponse from a JSON string
+local_users_list_response_instance = LocalUsersListResponse.from_json(json)
+# print the JSON string representation of the object
+print(LocalUsersListResponse.to_json())
+
+# convert the object into a dict
+local_users_list_response_dict = local_users_list_response_instance.to_dict()
+# create an instance of LocalUsersListResponse from a dict
+local_users_list_response_from_dict = LocalUsersListResponse.from_dict(local_users_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/MFAServersApi.md b/scm/identity_services/docs/MFAServersApi.md
new file mode 100644
index 00000000..563ae111
--- /dev/null
+++ b/scm/identity_services/docs/MFAServersApi.md
@@ -0,0 +1,441 @@
+# scm.identity_services.MFAServersApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_mfa_servers**](MFAServersApi.md#create_mfa_servers) | **POST** /mfa-servers | Create an MFA server
+[**delete_mfa_servers_by_id**](MFAServersApi.md#delete_mfa_servers_by_id) | **DELETE** /mfa-servers/{id} | Delete an MFA server
+[**get_mfa_servers_by_id**](MFAServersApi.md#get_mfa_servers_by_id) | **GET** /mfa-servers/{id} | Get an MFA server
+[**list_mfa_servers**](MFAServersApi.md#list_mfa_servers) | **GET** /mfa-servers | List MFA servers
+[**update_mfa_servers_by_id**](MFAServersApi.md#update_mfa_servers_by_id) | **PUT** /mfa-servers/{id} | Update an MFA server
+
+
+# **create_mfa_servers**
+> MfaServers create_mfa_servers(mfa_servers=mfa_servers)
+
+Create an MFA server
+
+Create a new MFA server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.mfa_servers import MfaServers
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.MFAServersApi(api_client)
+ mfa_servers = scm.identity_services.MfaServers() # MfaServers | Created (optional)
+
+ try:
+ # Create an MFA server
+ api_response = api_instance.create_mfa_servers(mfa_servers=mfa_servers)
+ print("The response of MFAServersApi->create_mfa_servers:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling MFAServersApi->create_mfa_servers: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **mfa_servers** | [**MfaServers**](MfaServers.md)| Created | [optional]
+
+### Return type
+
+[**MfaServers**](MfaServers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_mfa_servers_by_id**
+> delete_mfa_servers_by_id(id)
+
+Delete an MFA server
+
+Delete an MFA server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.MFAServersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an MFA server
+ api_instance.delete_mfa_servers_by_id(id)
+ except Exception as e:
+ print("Exception when calling MFAServersApi->delete_mfa_servers_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_mfa_servers_by_id**
+> MfaServers get_mfa_servers_by_id(id)
+
+Get an MFA server
+
+Get an existing MFA server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.mfa_servers import MfaServers
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.MFAServersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get an MFA server
+ api_response = api_instance.get_mfa_servers_by_id(id)
+ print("The response of MFAServersApi->get_mfa_servers_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling MFAServersApi->get_mfa_servers_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**MfaServers**](MfaServers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_mfa_servers**
+> MFAServersListResponse list_mfa_servers(position, name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List MFA servers
+
+Retrieve a list of MFA servers.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.mfa_servers_list_response import MFAServersListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.MFAServersApi(api_client)
+ position = pre # str | The relative position of the rule (default to pre)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List MFA servers
+ api_response = api_instance.list_mfa_servers(position, name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of MFAServersApi->list_mfa_servers:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling MFAServersApi->list_mfa_servers: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **position** | **str**| The relative position of the rule | [default to pre]
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**MFAServersListResponse**](MFAServersListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_mfa_servers_by_id**
+> MfaServers update_mfa_servers_by_id(id, mfa_servers=mfa_servers)
+
+Update an MFA server
+
+Update an existing MFA server.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.mfa_servers import MfaServers
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.MFAServersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ mfa_servers = scm.identity_services.MfaServers() # MfaServers | OK (optional)
+
+ try:
+ # Update an MFA server
+ api_response = api_instance.update_mfa_servers_by_id(id, mfa_servers=mfa_servers)
+ print("The response of MFAServersApi->update_mfa_servers_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling MFAServersApi->update_mfa_servers_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **mfa_servers** | [**MfaServers**](MfaServers.md)| OK | [optional]
+
+### Return type
+
+[**MfaServers**](MfaServers.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/MFAServersListResponse.md b/scm/identity_services/docs/MFAServersListResponse.md
new file mode 100644
index 00000000..add1129f
--- /dev/null
+++ b/scm/identity_services/docs/MFAServersListResponse.md
@@ -0,0 +1,32 @@
+# MFAServersListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[MfaServers]**](MfaServers.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.mfa_servers_list_response import MFAServersListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MFAServersListResponse from a JSON string
+mfa_servers_list_response_instance = MFAServersListResponse.from_json(json)
+# print the JSON string representation of the object
+print(MFAServersListResponse.to_json())
+
+# convert the object into a dict
+mfa_servers_list_response_dict = mfa_servers_list_response_instance.to_dict()
+# create an instance of MFAServersListResponse from a dict
+mfa_servers_list_response_from_dict = MFAServersListResponse.from_dict(mfa_servers_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/MfaServers.md b/scm/identity_services/docs/MfaServers.md
new file mode 100644
index 00000000..ccba8ce1
--- /dev/null
+++ b/scm/identity_services/docs/MfaServers.md
@@ -0,0 +1,35 @@
+# MfaServers
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the MFA server | [optional] [readonly]
+**mfa_cert_profile** | **str** | The MFA server certificate profile |
+**mfa_vendor_type** | [**MfaServersMfaVendorType**](MfaServersMfaVendorType.md) | | [optional]
+**name** | **str** | The name of the MFA server profile |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.mfa_servers import MfaServers
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MfaServers from a JSON string
+mfa_servers_instance = MfaServers.from_json(json)
+# print the JSON string representation of the object
+print(MfaServers.to_json())
+
+# convert the object into a dict
+mfa_servers_dict = mfa_servers_instance.to_dict()
+# create an instance of MfaServers from a dict
+mfa_servers_from_dict = MfaServers.from_dict(mfa_servers_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/MfaServersMfaVendorType.md b/scm/identity_services/docs/MfaServersMfaVendorType.md
new file mode 100644
index 00000000..8211bc34
--- /dev/null
+++ b/scm/identity_services/docs/MfaServersMfaVendorType.md
@@ -0,0 +1,33 @@
+# MfaServersMfaVendorType
+
+The MFA vendor type
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**duo_security_v2** | [**MfaServersMfaVendorTypeDuoSecurityV2**](MfaServersMfaVendorTypeDuoSecurityV2.md) | | [optional]
+**okta_adaptive_v1** | [**MfaServersMfaVendorTypeOktaAdaptiveV1**](MfaServersMfaVendorTypeOktaAdaptiveV1.md) | | [optional]
+**ping_identity_v1** | [**MfaServersMfaVendorTypePingIdentityV1**](MfaServersMfaVendorTypePingIdentityV1.md) | | [optional]
+**rsa_securid_access_v1** | [**MfaServersMfaVendorTypeRsaSecuridAccessV1**](MfaServersMfaVendorTypeRsaSecuridAccessV1.md) | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.mfa_servers_mfa_vendor_type import MfaServersMfaVendorType
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MfaServersMfaVendorType from a JSON string
+mfa_servers_mfa_vendor_type_instance = MfaServersMfaVendorType.from_json(json)
+# print the JSON string representation of the object
+print(MfaServersMfaVendorType.to_json())
+
+# convert the object into a dict
+mfa_servers_mfa_vendor_type_dict = mfa_servers_mfa_vendor_type_instance.to_dict()
+# create an instance of MfaServersMfaVendorType from a dict
+mfa_servers_mfa_vendor_type_from_dict = MfaServersMfaVendorType.from_dict(mfa_servers_mfa_vendor_type_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/MfaServersMfaVendorTypeDuoSecurityV2.md b/scm/identity_services/docs/MfaServersMfaVendorTypeDuoSecurityV2.md
new file mode 100644
index 00000000..c15a3705
--- /dev/null
+++ b/scm/identity_services/docs/MfaServersMfaVendorTypeDuoSecurityV2.md
@@ -0,0 +1,34 @@
+# MfaServersMfaVendorTypeDuoSecurityV2
+
+Integration with [Duo Security](https://duo.com/product)
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**duo_api_host** | **str** | Duo Security API hostname |
+**duo_baseuri** | **str** | Duo Security API base URI | [default to '/auth/v2']
+**duo_integration_key** | **str** | Duo Security integration key |
+**duo_secret_key** | **str** | Duo Security secret key |
+**duo_timeout** | **int** | Duo Security timeout (seconds) | [default to 30]
+
+## Example
+
+```python
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_duo_security_v2 import MfaServersMfaVendorTypeDuoSecurityV2
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MfaServersMfaVendorTypeDuoSecurityV2 from a JSON string
+mfa_servers_mfa_vendor_type_duo_security_v2_instance = MfaServersMfaVendorTypeDuoSecurityV2.from_json(json)
+# print the JSON string representation of the object
+print(MfaServersMfaVendorTypeDuoSecurityV2.to_json())
+
+# convert the object into a dict
+mfa_servers_mfa_vendor_type_duo_security_v2_dict = mfa_servers_mfa_vendor_type_duo_security_v2_instance.to_dict()
+# create an instance of MfaServersMfaVendorTypeDuoSecurityV2 from a dict
+mfa_servers_mfa_vendor_type_duo_security_v2_from_dict = MfaServersMfaVendorTypeDuoSecurityV2.from_dict(mfa_servers_mfa_vendor_type_duo_security_v2_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/MfaServersMfaVendorTypeOktaAdaptiveV1.md b/scm/identity_services/docs/MfaServersMfaVendorTypeOktaAdaptiveV1.md
new file mode 100644
index 00000000..895e180c
--- /dev/null
+++ b/scm/identity_services/docs/MfaServersMfaVendorTypeOktaAdaptiveV1.md
@@ -0,0 +1,34 @@
+# MfaServersMfaVendorTypeOktaAdaptiveV1
+
+Integration with [Okta Adaptive MFA](https://www.okta.com/products/adaptive-multi-factor-authentication)
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**okta_api_host** | **str** | Okta API hostname |
+**okta_baseuri** | **str** | | [default to '/api/v1']
+**okta_org** | **str** | Okta organization |
+**okta_timeout** | **int** | Okta timeout (seconds) | [default to 30]
+**okta_token** | **str** | Okta API token |
+
+## Example
+
+```python
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_okta_adaptive_v1 import MfaServersMfaVendorTypeOktaAdaptiveV1
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MfaServersMfaVendorTypeOktaAdaptiveV1 from a JSON string
+mfa_servers_mfa_vendor_type_okta_adaptive_v1_instance = MfaServersMfaVendorTypeOktaAdaptiveV1.from_json(json)
+# print the JSON string representation of the object
+print(MfaServersMfaVendorTypeOktaAdaptiveV1.to_json())
+
+# convert the object into a dict
+mfa_servers_mfa_vendor_type_okta_adaptive_v1_dict = mfa_servers_mfa_vendor_type_okta_adaptive_v1_instance.to_dict()
+# create an instance of MfaServersMfaVendorTypeOktaAdaptiveV1 from a dict
+mfa_servers_mfa_vendor_type_okta_adaptive_v1_from_dict = MfaServersMfaVendorTypeOktaAdaptiveV1.from_dict(mfa_servers_mfa_vendor_type_okta_adaptive_v1_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/MfaServersMfaVendorTypePingIdentityV1.md b/scm/identity_services/docs/MfaServersMfaVendorTypePingIdentityV1.md
new file mode 100644
index 00000000..bda48937
--- /dev/null
+++ b/scm/identity_services/docs/MfaServersMfaVendorTypePingIdentityV1.md
@@ -0,0 +1,35 @@
+# MfaServersMfaVendorTypePingIdentityV1
+
+Integation with [Ping Identity](https://www.pingidentity.com/en/platform.html)
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ping_api_host** | **str** | Ping Identity API hostname | [default to 'idpxny3lm.pingidentity.com']
+**ping_baseuri** | **str** | Ping Identity API base URI | [default to '/pingid/rest/4']
+**ping_org_alias** | **str** | Ping Identity client organization ID | [optional]
+**ping_timeout** | **int** | Ping Identity timeout (seconds) | [default to 30]
+**ping_token** | **str** | Ping Identity API token |
+**ping_use_base64_key** | **str** | Ping Identity Base64 key |
+
+## Example
+
+```python
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_ping_identity_v1 import MfaServersMfaVendorTypePingIdentityV1
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MfaServersMfaVendorTypePingIdentityV1 from a JSON string
+mfa_servers_mfa_vendor_type_ping_identity_v1_instance = MfaServersMfaVendorTypePingIdentityV1.from_json(json)
+# print the JSON string representation of the object
+print(MfaServersMfaVendorTypePingIdentityV1.to_json())
+
+# convert the object into a dict
+mfa_servers_mfa_vendor_type_ping_identity_v1_dict = mfa_servers_mfa_vendor_type_ping_identity_v1_instance.to_dict()
+# create an instance of MfaServersMfaVendorTypePingIdentityV1 from a dict
+mfa_servers_mfa_vendor_type_ping_identity_v1_from_dict = MfaServersMfaVendorTypePingIdentityV1.from_dict(mfa_servers_mfa_vendor_type_ping_identity_v1_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/MfaServersMfaVendorTypeRsaSecuridAccessV1.md b/scm/identity_services/docs/MfaServersMfaVendorTypeRsaSecuridAccessV1.md
new file mode 100644
index 00000000..bc02c76d
--- /dev/null
+++ b/scm/identity_services/docs/MfaServersMfaVendorTypeRsaSecuridAccessV1.md
@@ -0,0 +1,35 @@
+# MfaServersMfaVendorTypeRsaSecuridAccessV1
+
+Integration with [RSA SecurID](https://www.rsa.com/products/securid/)
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**rsa_accessid** | **str** | RSA SecurID access ID | [optional]
+**rsa_accesskey** | **str** | RSA SecurID access key | [optional]
+**rsa_api_host** | **str** | RSA SecurID hostname | [optional]
+**rsa_assurancepolicyid** | **str** | RSA SecurID assurance level | [optional]
+**rsa_baseuri** | **str** | RSA SecurID API base URI | [optional] [default to '/mfa/v1_1']
+**rsa_timeout** | **int** | RSA SecurID timeout (seconds) | [optional] [default to 30]
+
+## Example
+
+```python
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_rsa_securid_access_v1 import MfaServersMfaVendorTypeRsaSecuridAccessV1
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of MfaServersMfaVendorTypeRsaSecuridAccessV1 from a JSON string
+mfa_servers_mfa_vendor_type_rsa_securid_access_v1_instance = MfaServersMfaVendorTypeRsaSecuridAccessV1.from_json(json)
+# print the JSON string representation of the object
+print(MfaServersMfaVendorTypeRsaSecuridAccessV1.to_json())
+
+# convert the object into a dict
+mfa_servers_mfa_vendor_type_rsa_securid_access_v1_dict = mfa_servers_mfa_vendor_type_rsa_securid_access_v1_instance.to_dict()
+# create an instance of MfaServersMfaVendorTypeRsaSecuridAccessV1 from a dict
+mfa_servers_mfa_vendor_type_rsa_securid_access_v1_from_dict = MfaServersMfaVendorTypeRsaSecuridAccessV1.from_dict(mfa_servers_mfa_vendor_type_rsa_securid_access_v1_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/OCSPRespondersApi.md b/scm/identity_services/docs/OCSPRespondersApi.md
new file mode 100644
index 00000000..1dae310b
--- /dev/null
+++ b/scm/identity_services/docs/OCSPRespondersApi.md
@@ -0,0 +1,437 @@
+# scm.identity_services.OCSPRespondersApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_ocsp_responders**](OCSPRespondersApi.md#create_ocsp_responders) | **POST** /ocsp-responders | Create an OCSP responder
+[**delete_ocsp_responders_by_id**](OCSPRespondersApi.md#delete_ocsp_responders_by_id) | **DELETE** /ocsp-responders/{id} | Delete an OCSP responder
+[**get_ocsp_responders_by_id**](OCSPRespondersApi.md#get_ocsp_responders_by_id) | **GET** /ocsp-responders/{id} | Get an OCSP responder
+[**list_ocsp_responders**](OCSPRespondersApi.md#list_ocsp_responders) | **GET** /ocsp-responders | List OCSP responders
+[**update_ocsp_responders_by_id**](OCSPRespondersApi.md#update_ocsp_responders_by_id) | **PUT** /ocsp-responders/{id} | Update an OCSP responder
+
+
+# **create_ocsp_responders**
+> create_ocsp_responders(ocsp_responders=ocsp_responders)
+
+Create an OCSP responder
+
+Create a new OCSP responder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ocsp_responders import OcspResponders
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.OCSPRespondersApi(api_client)
+ ocsp_responders = scm.identity_services.OcspResponders() # OcspResponders | Created (optional)
+
+ try:
+ # Create an OCSP responder
+ api_instance.create_ocsp_responders(ocsp_responders=ocsp_responders)
+ except Exception as e:
+ print("Exception when calling OCSPRespondersApi->create_ocsp_responders: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **ocsp_responders** | [**OcspResponders**](OcspResponders.md)| Created | [optional]
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_ocsp_responders_by_id**
+> delete_ocsp_responders_by_id(id)
+
+Delete an OCSP responder
+
+Delete an OCSP responder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.OCSPRespondersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete an OCSP responder
+ api_instance.delete_ocsp_responders_by_id(id)
+ except Exception as e:
+ print("Exception when calling OCSPRespondersApi->delete_ocsp_responders_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_ocsp_responders_by_id**
+> OcspResponders get_ocsp_responders_by_id(id)
+
+Get an OCSP responder
+
+Get an existing OCSP responder
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ocsp_responders import OcspResponders
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.OCSPRespondersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get an OCSP responder
+ api_response = api_instance.get_ocsp_responders_by_id(id)
+ print("The response of OCSPRespondersApi->get_ocsp_responders_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling OCSPRespondersApi->get_ocsp_responders_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**OcspResponders**](OcspResponders.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_ocsp_responders**
+> OCSPRespondersListResponse list_ocsp_responders(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List OCSP responders
+
+Retrieve a list of OCSP responders.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ocsp_responders_list_response import OCSPRespondersListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.OCSPRespondersApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List OCSP responders
+ api_response = api_instance.list_ocsp_responders(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of OCSPRespondersApi->list_ocsp_responders:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling OCSPRespondersApi->list_ocsp_responders: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**OCSPRespondersListResponse**](OCSPRespondersListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_ocsp_responders_by_id**
+> OcspResponders update_ocsp_responders_by_id(id, ocsp_responders=ocsp_responders)
+
+Update an OCSP responder
+
+Update an existing OCSP responder.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.ocsp_responders import OcspResponders
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.OCSPRespondersApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ ocsp_responders = scm.identity_services.OcspResponders() # OcspResponders | OK (optional)
+
+ try:
+ # Update an OCSP responder
+ api_response = api_instance.update_ocsp_responders_by_id(id, ocsp_responders=ocsp_responders)
+ print("The response of OCSPRespondersApi->update_ocsp_responders_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling OCSPRespondersApi->update_ocsp_responders_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **ocsp_responders** | [**OcspResponders**](OcspResponders.md)| OK | [optional]
+
+### Return type
+
+[**OcspResponders**](OcspResponders.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/OCSPRespondersListResponse.md b/scm/identity_services/docs/OCSPRespondersListResponse.md
new file mode 100644
index 00000000..fd1bb6e4
--- /dev/null
+++ b/scm/identity_services/docs/OCSPRespondersListResponse.md
@@ -0,0 +1,32 @@
+# OCSPRespondersListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[OcspResponders]**](OcspResponders.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.ocsp_responders_list_response import OCSPRespondersListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of OCSPRespondersListResponse from a JSON string
+ocsp_responders_list_response_instance = OCSPRespondersListResponse.from_json(json)
+# print the JSON string representation of the object
+print(OCSPRespondersListResponse.to_json())
+
+# convert the object into a dict
+ocsp_responders_list_response_dict = ocsp_responders_list_response_instance.to_dict()
+# create an instance of OCSPRespondersListResponse from a dict
+ocsp_responders_list_response_from_dict = OCSPRespondersListResponse.from_dict(ocsp_responders_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/OcspResponders.md b/scm/identity_services/docs/OcspResponders.md
new file mode 100644
index 00000000..7e1a49aa
--- /dev/null
+++ b/scm/identity_services/docs/OcspResponders.md
@@ -0,0 +1,34 @@
+# OcspResponders
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**host_name** | **str** | The hostname or IP address of the OCSP server |
+**id** | **str** | The UUID of the OCSP responder profile | [readonly]
+**name** | **str** | The name of the OCSP responder profile |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.ocsp_responders import OcspResponders
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of OcspResponders from a JSON string
+ocsp_responders_instance = OcspResponders.from_json(json)
+# print the JSON string representation of the object
+print(OcspResponders.to_json())
+
+# convert the object into a dict
+ocsp_responders_dict = ocsp_responders_instance.to_dict()
+# create an instance of OcspResponders from a dict
+ocsp_responders_from_dict = OcspResponders.from_dict(ocsp_responders_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/RADIUSServerProfilesApi.md b/scm/identity_services/docs/RADIUSServerProfilesApi.md
new file mode 100644
index 00000000..71964b5d
--- /dev/null
+++ b/scm/identity_services/docs/RADIUSServerProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.RADIUSServerProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_radius_server_profiles**](RADIUSServerProfilesApi.md#create_radius_server_profiles) | **POST** /radius-server-profiles | Create a RADIUS server profile
+[**delete_radius_server_profiles_by_id**](RADIUSServerProfilesApi.md#delete_radius_server_profiles_by_id) | **DELETE** /radius-server-profiles/{id} | Delete a RADIUS server profile
+[**get_radius_server_profiles_by_id**](RADIUSServerProfilesApi.md#get_radius_server_profiles_by_id) | **GET** /radius-server-profiles/{id} | Get a RADIUS server profile
+[**list_radius_server_profiles**](RADIUSServerProfilesApi.md#list_radius_server_profiles) | **GET** /radius-server-profiles | List RADIUS server profiles
+[**update_radius_server_profiles_by_id**](RADIUSServerProfilesApi.md#update_radius_server_profiles_by_id) | **PUT** /radius-server-profiles/{id} | Update a RADIUS server profile
+
+
+# **create_radius_server_profiles**
+> RadiusServerProfiles create_radius_server_profiles(radius_server_profiles=radius_server_profiles)
+
+Create a RADIUS server profile
+
+Create a new RADIUS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.RADIUSServerProfilesApi(api_client)
+ radius_server_profiles = scm.identity_services.RadiusServerProfiles() # RadiusServerProfiles | Created (optional)
+
+ try:
+ # Create a RADIUS server profile
+ api_response = api_instance.create_radius_server_profiles(radius_server_profiles=radius_server_profiles)
+ print("The response of RADIUSServerProfilesApi->create_radius_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RADIUSServerProfilesApi->create_radius_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **radius_server_profiles** | [**RadiusServerProfiles**](RadiusServerProfiles.md)| Created | [optional]
+
+### Return type
+
+[**RadiusServerProfiles**](RadiusServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_radius_server_profiles_by_id**
+> delete_radius_server_profiles_by_id(id)
+
+Delete a RADIUS server profile
+
+Delete a RADIUS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.RADIUSServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a RADIUS server profile
+ api_instance.delete_radius_server_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling RADIUSServerProfilesApi->delete_radius_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_radius_server_profiles_by_id**
+> RadiusServerProfiles get_radius_server_profiles_by_id(id)
+
+Get a RADIUS server profile
+
+Get an existing RADIUS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.RADIUSServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a RADIUS server profile
+ api_response = api_instance.get_radius_server_profiles_by_id(id)
+ print("The response of RADIUSServerProfilesApi->get_radius_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RADIUSServerProfilesApi->get_radius_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**RadiusServerProfiles**](RadiusServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_radius_server_profiles**
+> RADIUSServerProfilesListResponse list_radius_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List RADIUS server profiles
+
+Retreive a list of RADIUS server profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.radius_server_profiles_list_response import RADIUSServerProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.RADIUSServerProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List RADIUS server profiles
+ api_response = api_instance.list_radius_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of RADIUSServerProfilesApi->list_radius_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RADIUSServerProfilesApi->list_radius_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**RADIUSServerProfilesListResponse**](RADIUSServerProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_radius_server_profiles_by_id**
+> RadiusServerProfiles update_radius_server_profiles_by_id(id, radius_server_profiles=radius_server_profiles)
+
+Update a RADIUS server profile
+
+Update an existing RADIUS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.RADIUSServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ radius_server_profiles = scm.identity_services.RadiusServerProfiles() # RadiusServerProfiles | OK (optional)
+
+ try:
+ # Update a RADIUS server profile
+ api_response = api_instance.update_radius_server_profiles_by_id(id, radius_server_profiles=radius_server_profiles)
+ print("The response of RADIUSServerProfilesApi->update_radius_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling RADIUSServerProfilesApi->update_radius_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **radius_server_profiles** | [**RadiusServerProfiles**](RadiusServerProfiles.md)| OK | [optional]
+
+### Return type
+
+[**RadiusServerProfiles**](RadiusServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/RADIUSServerProfilesListResponse.md b/scm/identity_services/docs/RADIUSServerProfilesListResponse.md
new file mode 100644
index 00000000..8bab1428
--- /dev/null
+++ b/scm/identity_services/docs/RADIUSServerProfilesListResponse.md
@@ -0,0 +1,32 @@
+# RADIUSServerProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[RadiusServerProfiles]**](RadiusServerProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.radius_server_profiles_list_response import RADIUSServerProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RADIUSServerProfilesListResponse from a JSON string
+radius_server_profiles_list_response_instance = RADIUSServerProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(RADIUSServerProfilesListResponse.to_json())
+
+# convert the object into a dict
+radius_server_profiles_list_response_dict = radius_server_profiles_list_response_instance.to_dict()
+# create an instance of RADIUSServerProfilesListResponse from a dict
+radius_server_profiles_list_response_from_dict = RADIUSServerProfilesListResponse.from_dict(radius_server_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/RadiusServerProfiles.md b/scm/identity_services/docs/RadiusServerProfiles.md
new file mode 100644
index 00000000..efa6bc38
--- /dev/null
+++ b/scm/identity_services/docs/RadiusServerProfiles.md
@@ -0,0 +1,37 @@
+# RadiusServerProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the RADIUS server profile | [optional] [readonly]
+**name** | **str** | The name of the RADIUS server profile |
+**protocol** | [**RadiusServerProfilesProtocol**](RadiusServerProfilesProtocol.md) | |
+**retries** | **int** | The number of RADIUS server retries | [optional]
+**server** | [**List[RadiusServerProfilesServerInner]**](RadiusServerProfilesServerInner.md) | |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**timeout** | **int** | The RADIUS server authentication timeout (seconds) | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RadiusServerProfiles from a JSON string
+radius_server_profiles_instance = RadiusServerProfiles.from_json(json)
+# print the JSON string representation of the object
+print(RadiusServerProfiles.to_json())
+
+# convert the object into a dict
+radius_server_profiles_dict = radius_server_profiles_instance.to_dict()
+# create an instance of RadiusServerProfiles from a dict
+radius_server_profiles_from_dict = RadiusServerProfiles.from_dict(radius_server_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/RadiusServerProfilesProtocol.md b/scm/identity_services/docs/RadiusServerProfilesProtocol.md
new file mode 100644
index 00000000..079c847b
--- /dev/null
+++ b/scm/identity_services/docs/RadiusServerProfilesProtocol.md
@@ -0,0 +1,34 @@
+# RadiusServerProfilesProtocol
+
+The RADIUS authentication protocol
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**chap** | **object** | | [optional]
+**eap_ttls_with_pap** | [**RadiusServerProfilesProtocolEAPTTLSWithPAP**](RadiusServerProfilesProtocolEAPTTLSWithPAP.md) | | [optional]
+**pap** | **object** | | [optional]
+**peap_mschapv2** | [**RadiusServerProfilesProtocolPEAPMSCHAPv2**](RadiusServerProfilesProtocolPEAPMSCHAPv2.md) | | [optional]
+**peap_with_gtc** | [**RadiusServerProfilesProtocolEAPTTLSWithPAP**](RadiusServerProfilesProtocolEAPTTLSWithPAP.md) | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.radius_server_profiles_protocol import RadiusServerProfilesProtocol
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RadiusServerProfilesProtocol from a JSON string
+radius_server_profiles_protocol_instance = RadiusServerProfilesProtocol.from_json(json)
+# print the JSON string representation of the object
+print(RadiusServerProfilesProtocol.to_json())
+
+# convert the object into a dict
+radius_server_profiles_protocol_dict = radius_server_profiles_protocol_instance.to_dict()
+# create an instance of RadiusServerProfilesProtocol from a dict
+radius_server_profiles_protocol_from_dict = RadiusServerProfilesProtocol.from_dict(radius_server_profiles_protocol_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/RadiusServerProfilesProtocolEAPTTLSWithPAP.md b/scm/identity_services/docs/RadiusServerProfilesProtocolEAPTTLSWithPAP.md
new file mode 100644
index 00000000..891c9b70
--- /dev/null
+++ b/scm/identity_services/docs/RadiusServerProfilesProtocolEAPTTLSWithPAP.md
@@ -0,0 +1,30 @@
+# RadiusServerProfilesProtocolEAPTTLSWithPAP
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**anon_outer_id** | **bool** | | [optional]
+**radius_cert_profile** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.radius_server_profiles_protocol_eapttls_with_pap import RadiusServerProfilesProtocolEAPTTLSWithPAP
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RadiusServerProfilesProtocolEAPTTLSWithPAP from a JSON string
+radius_server_profiles_protocol_eapttls_with_pap_instance = RadiusServerProfilesProtocolEAPTTLSWithPAP.from_json(json)
+# print the JSON string representation of the object
+print(RadiusServerProfilesProtocolEAPTTLSWithPAP.to_json())
+
+# convert the object into a dict
+radius_server_profiles_protocol_eapttls_with_pap_dict = radius_server_profiles_protocol_eapttls_with_pap_instance.to_dict()
+# create an instance of RadiusServerProfilesProtocolEAPTTLSWithPAP from a dict
+radius_server_profiles_protocol_eapttls_with_pap_from_dict = RadiusServerProfilesProtocolEAPTTLSWithPAP.from_dict(radius_server_profiles_protocol_eapttls_with_pap_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/RadiusServerProfilesProtocolPEAPMSCHAPv2.md b/scm/identity_services/docs/RadiusServerProfilesProtocolPEAPMSCHAPv2.md
new file mode 100644
index 00000000..49575134
--- /dev/null
+++ b/scm/identity_services/docs/RadiusServerProfilesProtocolPEAPMSCHAPv2.md
@@ -0,0 +1,31 @@
+# RadiusServerProfilesProtocolPEAPMSCHAPv2
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**allow_pwd_change** | **bool** | | [optional]
+**anon_outer_id** | **bool** | | [optional]
+**radius_cert_profile** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.radius_server_profiles_protocol_peapmschapv2 import RadiusServerProfilesProtocolPEAPMSCHAPv2
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RadiusServerProfilesProtocolPEAPMSCHAPv2 from a JSON string
+radius_server_profiles_protocol_peapmschapv2_instance = RadiusServerProfilesProtocolPEAPMSCHAPv2.from_json(json)
+# print the JSON string representation of the object
+print(RadiusServerProfilesProtocolPEAPMSCHAPv2.to_json())
+
+# convert the object into a dict
+radius_server_profiles_protocol_peapmschapv2_dict = radius_server_profiles_protocol_peapmschapv2_instance.to_dict()
+# create an instance of RadiusServerProfilesProtocolPEAPMSCHAPv2 from a dict
+radius_server_profiles_protocol_peapmschapv2_from_dict = RadiusServerProfilesProtocolPEAPMSCHAPv2.from_dict(radius_server_profiles_protocol_peapmschapv2_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/RadiusServerProfilesServerInner.md b/scm/identity_services/docs/RadiusServerProfilesServerInner.md
new file mode 100644
index 00000000..9112b67c
--- /dev/null
+++ b/scm/identity_services/docs/RadiusServerProfilesServerInner.md
@@ -0,0 +1,33 @@
+# RadiusServerProfilesServerInner
+
+The RADIUS server configuration
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**ip_address** | **str** | The IP address of the RADIUS server | [optional]
+**name** | **str** | The name of the RADIUS server | [optional]
+**port** | **int** | The RADIUS server port | [optional]
+**secret** | **str** | The RADIUS secret | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.radius_server_profiles_server_inner import RadiusServerProfilesServerInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RadiusServerProfilesServerInner from a JSON string
+radius_server_profiles_server_inner_instance = RadiusServerProfilesServerInner.from_json(json)
+# print the JSON string representation of the object
+print(RadiusServerProfilesServerInner.to_json())
+
+# convert the object into a dict
+radius_server_profiles_server_inner_dict = radius_server_profiles_server_inner_instance.to_dict()
+# create an instance of RadiusServerProfilesServerInner from a dict
+radius_server_profiles_server_inner_from_dict = RadiusServerProfilesServerInner.from_dict(radius_server_profiles_server_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/RuleBasedMove.md b/scm/identity_services/docs/RuleBasedMove.md
new file mode 100644
index 00000000..61264647
--- /dev/null
+++ b/scm/identity_services/docs/RuleBasedMove.md
@@ -0,0 +1,31 @@
+# RuleBasedMove
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**destination** | **str** | The position of the rule relative to other rules in this rulebase. |
+**destination_rule** | **str** | A destination target rule UUID. This is only used if the `destination` value is `before` or `after`. | [optional]
+**rulebase** | **str** | The position of the rule relative to the local rulebase |
+
+## Example
+
+```python
+from scm.identity_services.models.rule_based_move import RuleBasedMove
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of RuleBasedMove from a JSON string
+rule_based_move_instance = RuleBasedMove.from_json(json)
+# print the JSON string representation of the object
+print(RuleBasedMove.to_json())
+
+# convert the object into a dict
+rule_based_move_dict = rule_based_move_instance.to_dict()
+# create an instance of RuleBasedMove from a dict
+rule_based_move_from_dict = RuleBasedMove.from_dict(rule_based_move_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/SAMLServerProfilesApi.md b/scm/identity_services/docs/SAMLServerProfilesApi.md
new file mode 100644
index 00000000..4ca5d3db
--- /dev/null
+++ b/scm/identity_services/docs/SAMLServerProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.SAMLServerProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_saml_server_profiles**](SAMLServerProfilesApi.md#create_saml_server_profiles) | **POST** /saml-server-profiles | Create a SAML server profile
+[**delete_saml_server_profiles_by_id**](SAMLServerProfilesApi.md#delete_saml_server_profiles_by_id) | **DELETE** /saml-server-profiles/{id} | Delete a SAML server profile
+[**get_saml_server_profiles_by_id**](SAMLServerProfilesApi.md#get_saml_server_profiles_by_id) | **GET** /saml-server-profiles/{id} | Get a SAML server profile
+[**list_saml_server_profiles**](SAMLServerProfilesApi.md#list_saml_server_profiles) | **GET** /saml-server-profiles | List SAML server profiles
+[**update_saml_server_profiles_by_id**](SAMLServerProfilesApi.md#update_saml_server_profiles_by_id) | **PUT** /saml-server-profiles/{id} | Update a SAML server profile
+
+
+# **create_saml_server_profiles**
+> SamlServerProfiles create_saml_server_profiles(saml_server_profiles=saml_server_profiles)
+
+Create a SAML server profile
+
+Create a new SAML server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SAMLServerProfilesApi(api_client)
+ saml_server_profiles = scm.identity_services.SamlServerProfiles() # SamlServerProfiles | Created (optional)
+
+ try:
+ # Create a SAML server profile
+ api_response = api_instance.create_saml_server_profiles(saml_server_profiles=saml_server_profiles)
+ print("The response of SAMLServerProfilesApi->create_saml_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SAMLServerProfilesApi->create_saml_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **saml_server_profiles** | [**SamlServerProfiles**](SamlServerProfiles.md)| Created | [optional]
+
+### Return type
+
+[**SamlServerProfiles**](SamlServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | Created | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_saml_server_profiles_by_id**
+> delete_saml_server_profiles_by_id(id)
+
+Delete a SAML server profile
+
+Delete a SAML server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SAMLServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a SAML server profile
+ api_instance.delete_saml_server_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling SAMLServerProfilesApi->delete_saml_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_saml_server_profiles_by_id**
+> SamlServerProfiles get_saml_server_profiles_by_id(id)
+
+Get a SAML server profile
+
+Get an existing SAML server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SAMLServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a SAML server profile
+ api_response = api_instance.get_saml_server_profiles_by_id(id)
+ print("The response of SAMLServerProfilesApi->get_saml_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SAMLServerProfilesApi->get_saml_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**SamlServerProfiles**](SamlServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_saml_server_profiles**
+> SAMLServerProfilesListResponse list_saml_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List SAML server profiles
+
+Retrieve a list of SAML server profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.saml_server_profiles_list_response import SAMLServerProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SAMLServerProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List SAML server profiles
+ api_response = api_instance.list_saml_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of SAMLServerProfilesApi->list_saml_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SAMLServerProfilesApi->list_saml_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**SAMLServerProfilesListResponse**](SAMLServerProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_saml_server_profiles_by_id**
+> SamlServerProfiles update_saml_server_profiles_by_id(id, saml_server_profiles=saml_server_profiles)
+
+Update a SAML server profile
+
+Update an existing SAML server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SAMLServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ saml_server_profiles = scm.identity_services.SamlServerProfiles() # SamlServerProfiles | OK (optional)
+
+ try:
+ # Update a SAML server profile
+ api_response = api_instance.update_saml_server_profiles_by_id(id, saml_server_profiles=saml_server_profiles)
+ print("The response of SAMLServerProfilesApi->update_saml_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SAMLServerProfilesApi->update_saml_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **saml_server_profiles** | [**SamlServerProfiles**](SamlServerProfiles.md)| OK | [optional]
+
+### Return type
+
+[**SamlServerProfiles**](SamlServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/SAMLServerProfilesListResponse.md b/scm/identity_services/docs/SAMLServerProfilesListResponse.md
new file mode 100644
index 00000000..9c1e5d64
--- /dev/null
+++ b/scm/identity_services/docs/SAMLServerProfilesListResponse.md
@@ -0,0 +1,32 @@
+# SAMLServerProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[SamlServerProfiles]**](SamlServerProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.saml_server_profiles_list_response import SAMLServerProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SAMLServerProfilesListResponse from a JSON string
+saml_server_profiles_list_response_instance = SAMLServerProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(SAMLServerProfilesListResponse.to_json())
+
+# convert the object into a dict
+saml_server_profiles_list_response_dict = saml_server_profiles_list_response_instance.to_dict()
+# create an instance of SAMLServerProfilesListResponse from a dict
+saml_server_profiles_list_response_from_dict = SAMLServerProfilesListResponse.from_dict(saml_server_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/SCEPProfilesApi.md b/scm/identity_services/docs/SCEPProfilesApi.md
new file mode 100644
index 00000000..7eed28be
--- /dev/null
+++ b/scm/identity_services/docs/SCEPProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.SCEPProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_scep_profiles**](SCEPProfilesApi.md#create_scep_profiles) | **POST** /scep-profiles | Create a SCEP profile
+[**delete_scep_profiles_by_id**](SCEPProfilesApi.md#delete_scep_profiles_by_id) | **DELETE** /scep-profiles/{id} | Delete a SCEP profile
+[**get_scep_profiles_by_id**](SCEPProfilesApi.md#get_scep_profiles_by_id) | **GET** /scep-profiles/{id} | Get a SCEP profile
+[**list_scep_profiles**](SCEPProfilesApi.md#list_scep_profiles) | **GET** /scep-profiles | List SCEP profiles
+[**update_scep_profiles_by_id**](SCEPProfilesApi.md#update_scep_profiles_by_id) | **PUT** /scep-profiles/{id} | Update a SCEP profile
+
+
+# **create_scep_profiles**
+> ScepProfiles create_scep_profiles(scep_profiles=scep_profiles)
+
+Create a SCEP profile
+
+Create a new SCEP profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.scep_profiles import ScepProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SCEPProfilesApi(api_client)
+ scep_profiles = scm.identity_services.ScepProfiles() # ScepProfiles | Created (optional)
+
+ try:
+ # Create a SCEP profile
+ api_response = api_instance.create_scep_profiles(scep_profiles=scep_profiles)
+ print("The response of SCEPProfilesApi->create_scep_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SCEPProfilesApi->create_scep_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **scep_profiles** | [**ScepProfiles**](ScepProfiles.md)| Created | [optional]
+
+### Return type
+
+[**ScepProfiles**](ScepProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_scep_profiles_by_id**
+> delete_scep_profiles_by_id(id)
+
+Delete a SCEP profile
+
+Delete a SCEP profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SCEPProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a SCEP profile
+ api_instance.delete_scep_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling SCEPProfilesApi->delete_scep_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_scep_profiles_by_id**
+> ScepProfiles get_scep_profiles_by_id(id)
+
+Get a SCEP profile
+
+Get an existing SCEP profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.scep_profiles import ScepProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SCEPProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a SCEP profile
+ api_response = api_instance.get_scep_profiles_by_id(id)
+ print("The response of SCEPProfilesApi->get_scep_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SCEPProfilesApi->get_scep_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**ScepProfiles**](ScepProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_scep_profiles**
+> SCEPProfilesListResponse list_scep_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List SCEP profiles
+
+Retrieve a list of SCEP profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.scep_profiles_list_response import SCEPProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SCEPProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List SCEP profiles
+ api_response = api_instance.list_scep_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of SCEPProfilesApi->list_scep_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SCEPProfilesApi->list_scep_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**SCEPProfilesListResponse**](SCEPProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_scep_profiles_by_id**
+> ScepProfiles update_scep_profiles_by_id(id, scep_profiles=scep_profiles)
+
+Update a SCEP profile
+
+Update an existing SCEP profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.scep_profiles import ScepProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.SCEPProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ scep_profiles = scm.identity_services.ScepProfiles() # ScepProfiles | OK (optional)
+
+ try:
+ # Update a SCEP profile
+ api_response = api_instance.update_scep_profiles_by_id(id, scep_profiles=scep_profiles)
+ print("The response of SCEPProfilesApi->update_scep_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling SCEPProfilesApi->update_scep_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **scep_profiles** | [**ScepProfiles**](ScepProfiles.md)| OK | [optional]
+
+### Return type
+
+[**ScepProfiles**](ScepProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/SCEPProfilesListResponse.md b/scm/identity_services/docs/SCEPProfilesListResponse.md
new file mode 100644
index 00000000..da62b8bd
--- /dev/null
+++ b/scm/identity_services/docs/SCEPProfilesListResponse.md
@@ -0,0 +1,32 @@
+# SCEPProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[ScepProfiles]**](ScepProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.scep_profiles_list_response import SCEPProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SCEPProfilesListResponse from a JSON string
+scep_profiles_list_response_instance = SCEPProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(SCEPProfilesListResponse.to_json())
+
+# convert the object into a dict
+scep_profiles_list_response_dict = scep_profiles_list_response_instance.to_dict()
+# create an instance of SCEPProfilesListResponse from a dict
+scep_profiles_list_response_from_dict = SCEPProfilesListResponse.from_dict(scep_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/SamlServerProfiles.md b/scm/identity_services/docs/SamlServerProfiles.md
new file mode 100644
index 00000000..c3ffde74
--- /dev/null
+++ b/scm/identity_services/docs/SamlServerProfiles.md
@@ -0,0 +1,42 @@
+# SamlServerProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**certificate** | **str** | The identity provider certificate |
+**device** | **str** | The device in which the resource is defined | [optional]
+**entity_id** | **str** | The identity provider ID |
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the SAML server profile | [readonly]
+**max_clock_skew** | **int** | Maxiumum clock skew | [optional]
+**name** | **str** | The name of the SAML server profile |
+**slo_bindings** | **str** | SAML HTTP binding for SLO requests to the identity provider | [optional]
+**slo_url** | **str** | Identity provider SLO URL | [optional]
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**sso_bindings** | **str** | SAML HTTP binding for SSO requests to the identity provider | [default to 'post']
+**sso_url** | **str** | Identity provider SSO URL |
+**validate_idp_certificate** | **bool** | Validate the identity provider certificate? | [optional]
+**want_auth_requests_signed** | **bool** | Sign SAML message to the identity provider? | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of SamlServerProfiles from a JSON string
+saml_server_profiles_instance = SamlServerProfiles.from_json(json)
+# print the JSON string representation of the object
+print(SamlServerProfiles.to_json())
+
+# convert the object into a dict
+saml_server_profiles_dict = saml_server_profiles_instance.to_dict()
+# create an instance of SamlServerProfiles from a dict
+saml_server_profiles_from_dict = SamlServerProfiles.from_dict(saml_server_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ScepProfiles.md b/scm/identity_services/docs/ScepProfiles.md
new file mode 100644
index 00000000..93ed60e9
--- /dev/null
+++ b/scm/identity_services/docs/ScepProfiles.md
@@ -0,0 +1,45 @@
+# ScepProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**algorithm** | [**ScepProfilesAlgorithm**](ScepProfilesAlgorithm.md) | |
+**ca_identity_name** | **str** | Certificate Authority Identity |
+**certificate_attributes** | [**ScepProfilesCertificateAttributes**](ScepProfilesCertificateAttributes.md) | | [optional]
+**device** | **str** | The device in which the resource is defined | [optional]
+**digest** | **str** | Digest for CSR |
+**fingerprint** | **str** | CA Certificate Fingerprint | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the SCEP profile | [readonly]
+**name** | **str** | The name of the SCEP profile |
+**scep_ca_cert** | **str** | SCEP Server CA Certificate | [optional]
+**scep_challenge** | [**ScepProfilesScepChallenge**](ScepProfilesScepChallenge.md) | |
+**scep_client_cert** | **str** | SCEP Client Certificate | [optional]
+**scep_url** | **str** | SCEP server URL |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**subject** | **str** | Subject | [default to 'CN=$USERNAME']
+**use_as_digital_signature** | **bool** | Use as digital signature? | [optional]
+**use_for_key_encipherment** | **bool** | Use for key encipherment? | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.scep_profiles import ScepProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ScepProfiles from a JSON string
+scep_profiles_instance = ScepProfiles.from_json(json)
+# print the JSON string representation of the object
+print(ScepProfiles.to_json())
+
+# convert the object into a dict
+scep_profiles_dict = scep_profiles_instance.to_dict()
+# create an instance of ScepProfiles from a dict
+scep_profiles_from_dict = ScepProfiles.from_dict(scep_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ScepProfilesAlgorithm.md b/scm/identity_services/docs/ScepProfilesAlgorithm.md
new file mode 100644
index 00000000..743e32cc
--- /dev/null
+++ b/scm/identity_services/docs/ScepProfilesAlgorithm.md
@@ -0,0 +1,29 @@
+# ScepProfilesAlgorithm
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**rsa** | [**ScepProfilesAlgorithmRsa**](ScepProfilesAlgorithmRsa.md) | |
+
+## Example
+
+```python
+from scm.identity_services.models.scep_profiles_algorithm import ScepProfilesAlgorithm
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ScepProfilesAlgorithm from a JSON string
+scep_profiles_algorithm_instance = ScepProfilesAlgorithm.from_json(json)
+# print the JSON string representation of the object
+print(ScepProfilesAlgorithm.to_json())
+
+# convert the object into a dict
+scep_profiles_algorithm_dict = scep_profiles_algorithm_instance.to_dict()
+# create an instance of ScepProfilesAlgorithm from a dict
+scep_profiles_algorithm_from_dict = ScepProfilesAlgorithm.from_dict(scep_profiles_algorithm_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ScepProfilesAlgorithmRsa.md b/scm/identity_services/docs/ScepProfilesAlgorithmRsa.md
new file mode 100644
index 00000000..c3928fd0
--- /dev/null
+++ b/scm/identity_services/docs/ScepProfilesAlgorithmRsa.md
@@ -0,0 +1,30 @@
+# ScepProfilesAlgorithmRsa
+
+Key length (bits)
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**rsa_nbits** | **str** | |
+
+## Example
+
+```python
+from scm.identity_services.models.scep_profiles_algorithm_rsa import ScepProfilesAlgorithmRsa
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ScepProfilesAlgorithmRsa from a JSON string
+scep_profiles_algorithm_rsa_instance = ScepProfilesAlgorithmRsa.from_json(json)
+# print the JSON string representation of the object
+print(ScepProfilesAlgorithmRsa.to_json())
+
+# convert the object into a dict
+scep_profiles_algorithm_rsa_dict = scep_profiles_algorithm_rsa_instance.to_dict()
+# create an instance of ScepProfilesAlgorithmRsa from a dict
+scep_profiles_algorithm_rsa_from_dict = ScepProfilesAlgorithmRsa.from_dict(scep_profiles_algorithm_rsa_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ScepProfilesCertificateAttributes.md b/scm/identity_services/docs/ScepProfilesCertificateAttributes.md
new file mode 100644
index 00000000..a2d16aca
--- /dev/null
+++ b/scm/identity_services/docs/ScepProfilesCertificateAttributes.md
@@ -0,0 +1,32 @@
+# ScepProfilesCertificateAttributes
+
+Subject Alternative name type
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**dnsname** | **str** | | [optional]
+**rfc822name** | **str** | | [optional]
+**uniform_resource_identifier** | **str** | | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.scep_profiles_certificate_attributes import ScepProfilesCertificateAttributes
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ScepProfilesCertificateAttributes from a JSON string
+scep_profiles_certificate_attributes_instance = ScepProfilesCertificateAttributes.from_json(json)
+# print the JSON string representation of the object
+print(ScepProfilesCertificateAttributes.to_json())
+
+# convert the object into a dict
+scep_profiles_certificate_attributes_dict = scep_profiles_certificate_attributes_instance.to_dict()
+# create an instance of ScepProfilesCertificateAttributes from a dict
+scep_profiles_certificate_attributes_from_dict = ScepProfilesCertificateAttributes.from_dict(scep_profiles_certificate_attributes_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ScepProfilesScepChallenge.md b/scm/identity_services/docs/ScepProfilesScepChallenge.md
new file mode 100644
index 00000000..87d1c5bd
--- /dev/null
+++ b/scm/identity_services/docs/ScepProfilesScepChallenge.md
@@ -0,0 +1,32 @@
+# ScepProfilesScepChallenge
+
+One Time Password Challenge
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**dynamic** | [**ScepProfilesScepChallengeDynamic**](ScepProfilesScepChallengeDynamic.md) | | [optional]
+**fixed** | **str** | Challenge to use for SCEP server on mobile clients | [optional]
+**var_none** | **object** | No OTP | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.scep_profiles_scep_challenge import ScepProfilesScepChallenge
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ScepProfilesScepChallenge from a JSON string
+scep_profiles_scep_challenge_instance = ScepProfilesScepChallenge.from_json(json)
+# print the JSON string representation of the object
+print(ScepProfilesScepChallenge.to_json())
+
+# convert the object into a dict
+scep_profiles_scep_challenge_dict = scep_profiles_scep_challenge_instance.to_dict()
+# create an instance of ScepProfilesScepChallenge from a dict
+scep_profiles_scep_challenge_from_dict = ScepProfilesScepChallenge.from_dict(scep_profiles_scep_challenge_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/ScepProfilesScepChallengeDynamic.md b/scm/identity_services/docs/ScepProfilesScepChallengeDynamic.md
new file mode 100644
index 00000000..598d818c
--- /dev/null
+++ b/scm/identity_services/docs/ScepProfilesScepChallengeDynamic.md
@@ -0,0 +1,31 @@
+# ScepProfilesScepChallengeDynamic
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**otp_server_url** | **str** | OTP server URL | [optional]
+**password** | **str** | OTP password | [optional]
+**username** | **str** | OTP username | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.scep_profiles_scep_challenge_dynamic import ScepProfilesScepChallengeDynamic
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of ScepProfilesScepChallengeDynamic from a JSON string
+scep_profiles_scep_challenge_dynamic_instance = ScepProfilesScepChallengeDynamic.from_json(json)
+# print the JSON string representation of the object
+print(ScepProfilesScepChallengeDynamic.to_json())
+
+# convert the object into a dict
+scep_profiles_scep_challenge_dynamic_dict = scep_profiles_scep_challenge_dynamic_instance.to_dict()
+# create an instance of ScepProfilesScepChallengeDynamic from a dict
+scep_profiles_scep_challenge_dynamic_from_dict = ScepProfilesScepChallengeDynamic.from_dict(scep_profiles_scep_challenge_dynamic_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TACACSServerProfilesApi.md b/scm/identity_services/docs/TACACSServerProfilesApi.md
new file mode 100644
index 00000000..e8d96448
--- /dev/null
+++ b/scm/identity_services/docs/TACACSServerProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.TACACSServerProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_tacacs_server_profiles**](TACACSServerProfilesApi.md#create_tacacs_server_profiles) | **POST** /tacacs-server-profiles | Create a TACACS server profile
+[**delete_tacacs_server_profiles_by_id**](TACACSServerProfilesApi.md#delete_tacacs_server_profiles_by_id) | **DELETE** /tacacs-server-profiles/{id} | Delete a TACACS server profile
+[**get_tacacs_server_profiles_by_id**](TACACSServerProfilesApi.md#get_tacacs_server_profiles_by_id) | **GET** /tacacs-server-profiles/{id} | Get a TACACS server profile
+[**list_tacacs_server_profiles**](TACACSServerProfilesApi.md#list_tacacs_server_profiles) | **GET** /tacacs-server-profiles | List TACACS server profiles
+[**update_tacacs_server_profiles_by_id**](TACACSServerProfilesApi.md#update_tacacs_server_profiles_by_id) | **PUT** /tacacs-server-profiles/{id} | Update a TACACS server profile
+
+
+# **create_tacacs_server_profiles**
+> TacacsServerProfiles create_tacacs_server_profiles(tacacs_server_profiles=tacacs_server_profiles)
+
+Create a TACACS server profile
+
+Create a new TACACS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TACACSServerProfilesApi(api_client)
+ tacacs_server_profiles = scm.identity_services.TacacsServerProfiles() # TacacsServerProfiles | Created (optional)
+
+ try:
+ # Create a TACACS server profile
+ api_response = api_instance.create_tacacs_server_profiles(tacacs_server_profiles=tacacs_server_profiles)
+ print("The response of TACACSServerProfilesApi->create_tacacs_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TACACSServerProfilesApi->create_tacacs_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **tacacs_server_profiles** | [**TacacsServerProfiles**](TacacsServerProfiles.md)| Created | [optional]
+
+### Return type
+
+[**TacacsServerProfiles**](TacacsServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_tacacs_server_profiles_by_id**
+> delete_tacacs_server_profiles_by_id(id)
+
+Delete a TACACS server profile
+
+Delete a TACACS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TACACSServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a TACACS server profile
+ api_instance.delete_tacacs_server_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling TACACSServerProfilesApi->delete_tacacs_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_tacacs_server_profiles_by_id**
+> TacacsServerProfiles get_tacacs_server_profiles_by_id(id)
+
+Get a TACACS server profile
+
+Get an existing TACACS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TACACSServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a TACACS server profile
+ api_response = api_instance.get_tacacs_server_profiles_by_id(id)
+ print("The response of TACACSServerProfilesApi->get_tacacs_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TACACSServerProfilesApi->get_tacacs_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**TacacsServerProfiles**](TacacsServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_tacacs_server_profiles**
+> TACACSServerProfilesListResponse list_tacacs_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List TACACS server profiles
+
+Retrieve a list of TACACS server profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tacacs_server_profiles_list_response import TACACSServerProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TACACSServerProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List TACACS server profiles
+ api_response = api_instance.list_tacacs_server_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of TACACSServerProfilesApi->list_tacacs_server_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TACACSServerProfilesApi->list_tacacs_server_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**TACACSServerProfilesListResponse**](TACACSServerProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_tacacs_server_profiles_by_id**
+> TacacsServerProfiles update_tacacs_server_profiles_by_id(id, tacacs_server_profiles=tacacs_server_profiles)
+
+Update a TACACS server profile
+
+Update an existing TACACS server profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TACACSServerProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ tacacs_server_profiles = scm.identity_services.TacacsServerProfiles() # TacacsServerProfiles | OK (optional)
+
+ try:
+ # Update a TACACS server profile
+ api_response = api_instance.update_tacacs_server_profiles_by_id(id, tacacs_server_profiles=tacacs_server_profiles)
+ print("The response of TACACSServerProfilesApi->update_tacacs_server_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TACACSServerProfilesApi->update_tacacs_server_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **tacacs_server_profiles** | [**TacacsServerProfiles**](TacacsServerProfiles.md)| OK | [optional]
+
+### Return type
+
+[**TacacsServerProfiles**](TacacsServerProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/TACACSServerProfilesListResponse.md b/scm/identity_services/docs/TACACSServerProfilesListResponse.md
new file mode 100644
index 00000000..743e3a55
--- /dev/null
+++ b/scm/identity_services/docs/TACACSServerProfilesListResponse.md
@@ -0,0 +1,32 @@
+# TACACSServerProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[TacacsServerProfiles]**](TacacsServerProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.tacacs_server_profiles_list_response import TACACSServerProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TACACSServerProfilesListResponse from a JSON string
+tacacs_server_profiles_list_response_instance = TACACSServerProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(TACACSServerProfilesListResponse.to_json())
+
+# convert the object into a dict
+tacacs_server_profiles_list_response_dict = tacacs_server_profiles_list_response_instance.to_dict()
+# create an instance of TACACSServerProfilesListResponse from a dict
+tacacs_server_profiles_list_response_from_dict = TACACSServerProfilesListResponse.from_dict(tacacs_server_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TLSServiceProfilesApi.md b/scm/identity_services/docs/TLSServiceProfilesApi.md
new file mode 100644
index 00000000..c3a1ca68
--- /dev/null
+++ b/scm/identity_services/docs/TLSServiceProfilesApi.md
@@ -0,0 +1,439 @@
+# scm.identity_services.TLSServiceProfilesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**create_tls_service_profiles**](TLSServiceProfilesApi.md#create_tls_service_profiles) | **POST** /tls-service-profiles | Create a TLS service profile
+[**delete_tls_service_profiles_by_id**](TLSServiceProfilesApi.md#delete_tls_service_profiles_by_id) | **DELETE** /tls-service-profiles/{id} | Delete a TLS service profile
+[**get_tls_service_profiles_by_id**](TLSServiceProfilesApi.md#get_tls_service_profiles_by_id) | **GET** /tls-service-profiles/{id} | Get a TLS service profile
+[**list_tls_service_profiles**](TLSServiceProfilesApi.md#list_tls_service_profiles) | **GET** /tls-service-profiles | List TLS service profiles
+[**update_tls_service_profiles_by_id**](TLSServiceProfilesApi.md#update_tls_service_profiles_by_id) | **PUT** /tls-service-profiles/{id} | Update a TLS service profile
+
+
+# **create_tls_service_profiles**
+> TlsServiceProfiles create_tls_service_profiles(tls_service_profiles=tls_service_profiles)
+
+Create a TLS service profile
+
+Create a new TLS service profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TLSServiceProfilesApi(api_client)
+ tls_service_profiles = scm.identity_services.TlsServiceProfiles() # TlsServiceProfiles | Created (optional)
+
+ try:
+ # Create a TLS service profile
+ api_response = api_instance.create_tls_service_profiles(tls_service_profiles=tls_service_profiles)
+ print("The response of TLSServiceProfilesApi->create_tls_service_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TLSServiceProfilesApi->create_tls_service_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **tls_service_profiles** | [**TlsServiceProfiles**](TlsServiceProfiles.md)| Created | [optional]
+
+### Return type
+
+[**TlsServiceProfiles**](TlsServiceProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**201** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **delete_tls_service_profiles_by_id**
+> delete_tls_service_profiles_by_id(id)
+
+Delete a TLS service profile
+
+Delete a TLS service profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TLSServiceProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Delete a TLS service profile
+ api_instance.delete_tls_service_profiles_by_id(id)
+ except Exception as e:
+ print("Exception when calling TLSServiceProfilesApi->delete_tls_service_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+void (empty response body)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **get_tls_service_profiles_by_id**
+> TlsServiceProfiles get_tls_service_profiles_by_id(id)
+
+Get a TLS service profile
+
+Get an existing TLS service profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TLSServiceProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+
+ try:
+ # Get a TLS service profile
+ api_response = api_instance.get_tls_service_profiles_by_id(id)
+ print("The response of TLSServiceProfilesApi->get_tls_service_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TLSServiceProfilesApi->get_tls_service_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+
+### Return type
+
+[**TlsServiceProfiles**](TlsServiceProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **list_tls_service_profiles**
+> TLSServiceProfilesListResponse list_tls_service_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List TLS service profiles
+
+Retrieve a list of TLS service profiles.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tls_service_profiles_list_response import TLSServiceProfilesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TLSServiceProfilesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List TLS service profiles
+ api_response = api_instance.list_tls_service_profiles(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of TLSServiceProfilesApi->list_tls_service_profiles:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TLSServiceProfilesApi->list_tls_service_profiles: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**TLSServiceProfilesListResponse**](TLSServiceProfilesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **update_tls_service_profiles_by_id**
+> TlsServiceProfiles update_tls_service_profiles_by_id(id, tls_service_profiles=tls_service_profiles)
+
+Update a TLS service profile
+
+Update an existing TLS service profile.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TLSServiceProfilesApi(api_client)
+ id = '123e4567-e89b-12d3-a456-426655440000' # str | The UUID of the configuration resource
+ tls_service_profiles = scm.identity_services.TlsServiceProfiles() # TlsServiceProfiles | OK (optional)
+
+ try:
+ # Update a TLS service profile
+ api_response = api_instance.update_tls_service_profiles_by_id(id, tls_service_profiles=tls_service_profiles)
+ print("The response of TLSServiceProfilesApi->update_tls_service_profiles_by_id:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TLSServiceProfilesApi->update_tls_service_profiles_by_id: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **id** | **str**| The UUID of the configuration resource |
+ **tls_service_profiles** | [**TlsServiceProfiles**](TlsServiceProfiles.md)| OK | [optional]
+
+### Return type
+
+[**TlsServiceProfiles**](TlsServiceProfiles.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**409** | Conflict | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/TLSServiceProfilesListResponse.md b/scm/identity_services/docs/TLSServiceProfilesListResponse.md
new file mode 100644
index 00000000..e9edfc45
--- /dev/null
+++ b/scm/identity_services/docs/TLSServiceProfilesListResponse.md
@@ -0,0 +1,32 @@
+# TLSServiceProfilesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[TlsServiceProfiles]**](TlsServiceProfiles.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.tls_service_profiles_list_response import TLSServiceProfilesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TLSServiceProfilesListResponse from a JSON string
+tls_service_profiles_list_response_instance = TLSServiceProfilesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(TLSServiceProfilesListResponse.to_json())
+
+# convert the object into a dict
+tls_service_profiles_list_response_dict = tls_service_profiles_list_response_instance.to_dict()
+# create an instance of TLSServiceProfilesListResponse from a dict
+tls_service_profiles_list_response_from_dict = TLSServiceProfilesListResponse.from_dict(tls_service_profiles_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TacacsServerProfiles.md b/scm/identity_services/docs/TacacsServerProfiles.md
new file mode 100644
index 00000000..f22466e1
--- /dev/null
+++ b/scm/identity_services/docs/TacacsServerProfiles.md
@@ -0,0 +1,37 @@
+# TacacsServerProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the TACACS+ server profile | [readonly]
+**name** | **str** | The name of the TACACS+ server profile |
+**protocol** | **str** | The TACACS+ authentication protocol |
+**server** | [**List[TacacsServerProfilesServerInner]**](TacacsServerProfilesServerInner.md) | The TACACS+ server configuration |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+**timeout** | **int** | The TACACS+ timeout (seconds) | [optional]
+**use_single_connection** | **bool** | Use a single TACACS+ connection? | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TacacsServerProfiles from a JSON string
+tacacs_server_profiles_instance = TacacsServerProfiles.from_json(json)
+# print the JSON string representation of the object
+print(TacacsServerProfiles.to_json())
+
+# convert the object into a dict
+tacacs_server_profiles_dict = tacacs_server_profiles_instance.to_dict()
+# create an instance of TacacsServerProfiles from a dict
+tacacs_server_profiles_from_dict = TacacsServerProfiles.from_dict(tacacs_server_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TacacsServerProfilesServerInner.md b/scm/identity_services/docs/TacacsServerProfilesServerInner.md
new file mode 100644
index 00000000..d67325a5
--- /dev/null
+++ b/scm/identity_services/docs/TacacsServerProfilesServerInner.md
@@ -0,0 +1,32 @@
+# TacacsServerProfilesServerInner
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**address** | **str** | The IP address of the TACACS+ server | [optional]
+**name** | **str** | The name of the TACACS+ server | [optional]
+**port** | **int** | The TACACS+ server port | [optional]
+**secret** | **str** | The TACACS+ secret | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.tacacs_server_profiles_server_inner import TacacsServerProfilesServerInner
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TacacsServerProfilesServerInner from a JSON string
+tacacs_server_profiles_server_inner_instance = TacacsServerProfilesServerInner.from_json(json)
+# print the JSON string representation of the object
+print(TacacsServerProfilesServerInner.to_json())
+
+# convert the object into a dict
+tacacs_server_profiles_server_inner_dict = tacacs_server_profiles_server_inner_instance.to_dict()
+# create an instance of TacacsServerProfilesServerInner from a dict
+tacacs_server_profiles_server_inner_from_dict = TacacsServerProfilesServerInner.from_dict(tacacs_server_profiles_server_inner_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TlsServiceProfiles.md b/scm/identity_services/docs/TlsServiceProfiles.md
new file mode 100644
index 00000000..85f248a8
--- /dev/null
+++ b/scm/identity_services/docs/TlsServiceProfiles.md
@@ -0,0 +1,35 @@
+# TlsServiceProfiles
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**certificate** | **str** | Certificate name |
+**device** | **str** | The device in which the resource is defined | [optional]
+**folder** | **str** | The folder in which the resource is defined | [optional]
+**id** | **str** | The UUID of the TLS service profile | [readonly]
+**name** | **str** | TLS service profile name. The value is `muCustomDomainSSLProfile` when it is used on mobile-agent infra settings. |
+**protocol_settings** | [**TlsServiceProfilesProtocolSettings**](TlsServiceProfilesProtocolSettings.md) | |
+**snippet** | **str** | The snippet in which the resource is defined | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TlsServiceProfiles from a JSON string
+tls_service_profiles_instance = TlsServiceProfiles.from_json(json)
+# print the JSON string representation of the object
+print(TlsServiceProfiles.to_json())
+
+# convert the object into a dict
+tls_service_profiles_dict = tls_service_profiles_instance.to_dict()
+# create an instance of TlsServiceProfiles from a dict
+tls_service_profiles_from_dict = TlsServiceProfiles.from_dict(tls_service_profiles_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TlsServiceProfilesProtocolSettings.md b/scm/identity_services/docs/TlsServiceProfilesProtocolSettings.md
new file mode 100644
index 00000000..97b2dd30
--- /dev/null
+++ b/scm/identity_services/docs/TlsServiceProfilesProtocolSettings.md
@@ -0,0 +1,41 @@
+# TlsServiceProfilesProtocolSettings
+
+Protocol settings
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**auth_algo_sha1** | **bool** | Allow SHA1 authentication? | [optional]
+**auth_algo_sha256** | **bool** | Allow SHA256 authentication? | [optional]
+**auth_algo_sha384** | **bool** | Allow SHA384 authentication? | [optional]
+**enc_algo_aes_128_cbc** | **bool** | Allow AES-128-CBC algorithm? | [optional]
+**enc_algo_aes_128_gcm** | **bool** | Allow AES-128-GCM algorithm? | [optional]
+**enc_algo_aes_256_cbc** | **bool** | Allow AES-256-CBC algorithm? | [optional]
+**enc_algo_aes_256_gcm** | **bool** | Allow algorithm AES-256-GCM | [optional]
+**keyxchg_algo_dhe** | **bool** | Allow DHE algorithm? | [optional]
+**keyxchg_algo_ecdhe** | **bool** | Allow ECDHE algorithm? | [optional]
+**keyxchg_algo_rsa** | **bool** | Allow RSA algorithm? | [optional]
+**max_version** | **str** | Maximum TLS version | [optional]
+**min_version** | **str** | Minimum TLS version | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.tls_service_profiles_protocol_settings import TlsServiceProfilesProtocolSettings
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TlsServiceProfilesProtocolSettings from a JSON string
+tls_service_profiles_protocol_settings_instance = TlsServiceProfilesProtocolSettings.from_json(json)
+# print the JSON string representation of the object
+print(TlsServiceProfilesProtocolSettings.to_json())
+
+# convert the object into a dict
+tls_service_profiles_protocol_settings_dict = tls_service_profiles_protocol_settings_instance.to_dict()
+# create an instance of TlsServiceProfilesProtocolSettings from a dict
+tls_service_profiles_protocol_settings_from_dict = TlsServiceProfilesProtocolSettings.from_dict(tls_service_profiles_protocol_settings_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TrustedCertificateAuthorities.md b/scm/identity_services/docs/TrustedCertificateAuthorities.md
new file mode 100644
index 00000000..a09432d6
--- /dev/null
+++ b/scm/identity_services/docs/TrustedCertificateAuthorities.md
@@ -0,0 +1,38 @@
+# TrustedCertificateAuthorities
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**common_name** | **str** | The trusted certificate authority common name | [optional]
+**expiry_epoch** | **str** | | [optional]
+**filename** | **str** | Certificate filename | [optional]
+**id** | **str** | The UUID of the trusted certificate authority | [optional] [readonly]
+**issuer** | **str** | Issuer | [optional]
+**name** | **str** | The trusted certificate authority name | [optional]
+**not_valid_after** | **str** | Not valid after this date | [optional]
+**not_valid_before** | **str** | Not valid before this date | [optional]
+**serial_number** | **str** | Serial number | [optional]
+**subject** | **str** | Subject | [optional]
+
+## Example
+
+```python
+from scm.identity_services.models.trusted_certificate_authorities import TrustedCertificateAuthorities
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrustedCertificateAuthorities from a JSON string
+trusted_certificate_authorities_instance = TrustedCertificateAuthorities.from_json(json)
+# print the JSON string representation of the object
+print(TrustedCertificateAuthorities.to_json())
+
+# convert the object into a dict
+trusted_certificate_authorities_dict = trusted_certificate_authorities_instance.to_dict()
+# create an instance of TrustedCertificateAuthorities from a dict
+trusted_certificate_authorities_from_dict = TrustedCertificateAuthorities.from_dict(trusted_certificate_authorities_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/docs/TrustedCertificateAuthoritiesApi.md b/scm/identity_services/docs/TrustedCertificateAuthoritiesApi.md
new file mode 100644
index 00000000..87a84ec5
--- /dev/null
+++ b/scm/identity_services/docs/TrustedCertificateAuthoritiesApi.md
@@ -0,0 +1,102 @@
+# scm.identity_services.TrustedCertificateAuthoritiesApi
+
+All URIs are relative to *https://api.strata.paloaltonetworks.com/config/identity/v1*
+
+Method | HTTP request | Description
+------------- | ------------- | -------------
+[**list_trusted_certificate_authorities**](TrustedCertificateAuthoritiesApi.md#list_trusted_certificate_authorities) | **GET** /trusted-certificate-authorities | List trusted certificate authorities
+
+
+# **list_trusted_certificate_authorities**
+> TrustedCertificateAuthoritiesListResponse list_trusted_certificate_authorities(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+
+List trusted certificate authorities
+
+Retrieve a list of trusted certificate authorities.
+
+### Example
+
+* Bearer (JWT) Authentication (scmToken):
+
+```python
+import scm.identity_services
+from scm.identity_services.models.trusted_certificate_authorities_list_response import TrustedCertificateAuthoritiesListResponse
+from scm.identity_services.rest import ApiException
+from pprint import pprint
+
+# Defining the host is optional and defaults to https://api.strata.paloaltonetworks.com/config/identity/v1
+# See configuration.py for a list of all supported configuration parameters.
+configuration = scm.identity_services.Configuration(
+ host = "https://api.strata.paloaltonetworks.com/config/identity/v1"
+)
+
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+
+# Configure Bearer authorization (JWT): scmToken
+configuration = scm.identity_services.Configuration(
+ access_token = os.environ["BEARER_TOKEN"]
+)
+
+# Enter a context with an instance of the API client
+with scm.identity_services.ApiClient(configuration) as api_client:
+ # Create an instance of the API class
+ api_instance = scm.identity_services.TrustedCertificateAuthoritiesApi(api_client)
+ name = 'name_example' # str | The name of the configuration resource (optional)
+ folder = 'folder_example' # str | The folder in which the resource is defined (optional)
+ snippet = 'snippet_example' # str | The snippet in which the resource is defined (optional)
+ device = 'device_example' # str | The device in which the resource is defined (optional)
+ limit = 200 # int | The maximum number of results per page (optional) (default to 200)
+ offset = 0 # int | The offset into the list of results returned (optional) (default to 0)
+
+ try:
+ # List trusted certificate authorities
+ api_response = api_instance.list_trusted_certificate_authorities(name=name, folder=folder, snippet=snippet, device=device, limit=limit, offset=offset)
+ print("The response of TrustedCertificateAuthoritiesApi->list_trusted_certificate_authorities:\n")
+ pprint(api_response)
+ except Exception as e:
+ print("Exception when calling TrustedCertificateAuthoritiesApi->list_trusted_certificate_authorities: %s\n" % e)
+```
+
+
+
+### Parameters
+
+
+Name | Type | Description | Notes
+------------- | ------------- | ------------- | -------------
+ **name** | **str**| The name of the configuration resource | [optional]
+ **folder** | **str**| The folder in which the resource is defined | [optional]
+ **snippet** | **str**| The snippet in which the resource is defined | [optional]
+ **device** | **str**| The device in which the resource is defined | [optional]
+ **limit** | **int**| The maximum number of results per page | [optional] [default to 200]
+ **offset** | **int**| The offset into the list of results returned | [optional] [default to 0]
+
+### Return type
+
+[**TrustedCertificateAuthoritiesListResponse**](TrustedCertificateAuthoritiesListResponse.md)
+
+### Authorization
+
+[scmToken](../README.md#scmToken)
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: application/json
+
+### HTTP response details
+
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+**200** | OK | - |
+**400** | Bad Request | - |
+**401** | Unauthorized | - |
+**403** | Forbidden | - |
+**404** | Not Found | - |
+**0** | General Errors | - |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
diff --git a/scm/identity_services/docs/TrustedCertificateAuthoritiesListResponse.md b/scm/identity_services/docs/TrustedCertificateAuthoritiesListResponse.md
new file mode 100644
index 00000000..dadca2ac
--- /dev/null
+++ b/scm/identity_services/docs/TrustedCertificateAuthoritiesListResponse.md
@@ -0,0 +1,32 @@
+# TrustedCertificateAuthoritiesListResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**data** | [**List[TrustedCertificateAuthorities]**](TrustedCertificateAuthorities.md) | |
+**limit** | **int** | The maximum number of results per page | [default to 200]
+**offset** | **int** | The offset into the list of results returned | [default to 0]
+**total** | **int** | The total count of results |
+
+## Example
+
+```python
+from scm.identity_services.models.trusted_certificate_authorities_list_response import TrustedCertificateAuthoritiesListResponse
+
+# TODO update the JSON string below
+json = "{}"
+# create an instance of TrustedCertificateAuthoritiesListResponse from a JSON string
+trusted_certificate_authorities_list_response_instance = TrustedCertificateAuthoritiesListResponse.from_json(json)
+# print the JSON string representation of the object
+print(TrustedCertificateAuthoritiesListResponse.to_json())
+
+# convert the object into a dict
+trusted_certificate_authorities_list_response_dict = trusted_certificate_authorities_list_response_instance.to_dict()
+# create an instance of TrustedCertificateAuthoritiesListResponse from a dict
+trusted_certificate_authorities_list_response_from_dict = TrustedCertificateAuthoritiesListResponse.from_dict(trusted_certificate_authorities_list_response_dict)
+```
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
+
+
diff --git a/scm/identity_services/exceptions.py b/scm/identity_services/exceptions.py
new file mode 100644
index 00000000..62a1ee9f
--- /dev/null
+++ b/scm/identity_services/exceptions.py
@@ -0,0 +1,200 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+from typing import Any, Optional
+from typing_extensions import Self
+
+class OpenApiException(Exception):
+ """The base exception class for all OpenAPIExceptions"""
+
+
+class ApiTypeError(OpenApiException, TypeError):
+ def __init__(self, msg, path_to_item=None, valid_classes=None,
+ key_type=None) -> None:
+ """ Raises an exception for TypeErrors
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list): a list of keys an indices to get to the
+ current_item
+ None if unset
+ valid_classes (tuple): the primitive classes that current item
+ should be an instance of
+ None if unset
+ key_type (bool): False if our value is a value in a dict
+ True if it is a key in a dict
+ False if our item is an item in a list
+ None if unset
+ """
+ self.path_to_item = path_to_item
+ self.valid_classes = valid_classes
+ self.key_type = key_type
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiTypeError, self).__init__(full_msg)
+
+
+class ApiValueError(OpenApiException, ValueError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (list) the path to the exception in the
+ received_data dict. None if unset
+ """
+
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiValueError, self).__init__(full_msg)
+
+
+class ApiAttributeError(OpenApiException, AttributeError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Raised when an attribute reference or assignment fails.
+
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiAttributeError, self).__init__(full_msg)
+
+
+class ApiKeyError(OpenApiException, KeyError):
+ def __init__(self, msg, path_to_item=None) -> None:
+ """
+ Args:
+ msg (str): the exception message
+
+ Keyword Args:
+ path_to_item (None/list) the path to the exception in the
+ received_data dict
+ """
+ self.path_to_item = path_to_item
+ full_msg = msg
+ if path_to_item:
+ full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
+ super(ApiKeyError, self).__init__(full_msg)
+
+
+class ApiException(OpenApiException):
+
+ def __init__(
+ self,
+ status=None,
+ reason=None,
+ http_resp=None,
+ *,
+ body: Optional[str] = None,
+ data: Optional[Any] = None,
+ ) -> None:
+ self.status = status
+ self.reason = reason
+ self.body = body
+ self.data = data
+ self.headers = None
+
+ if http_resp:
+ if self.status is None:
+ self.status = http_resp.status
+ if self.reason is None:
+ self.reason = http_resp.reason
+ if self.body is None:
+ try:
+ self.body = http_resp.data.decode('utf-8')
+ except Exception:
+ pass
+ self.headers = http_resp.getheaders()
+
+ @classmethod
+ def from_response(
+ cls,
+ *,
+ http_resp,
+ body: Optional[str],
+ data: Optional[Any],
+ ) -> Self:
+ if http_resp.status == 400:
+ raise BadRequestException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 401:
+ raise UnauthorizedException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 403:
+ raise ForbiddenException(http_resp=http_resp, body=body, data=data)
+
+ if http_resp.status == 404:
+ raise NotFoundException(http_resp=http_resp, body=body, data=data)
+
+ if 500 <= http_resp.status <= 599:
+ raise ServiceException(http_resp=http_resp, body=body, data=data)
+ raise ApiException(http_resp=http_resp, body=body, data=data)
+
+ def __str__(self):
+ """Custom error messages for exception"""
+ error_message = "({0})\n"\
+ "Reason: {1}\n".format(self.status, self.reason)
+ if self.headers:
+ error_message += "HTTP response headers: {0}\n".format(
+ self.headers)
+
+ if self.data or self.body:
+ error_message += "HTTP response body: {0}\n".format(self.data or self.body)
+
+ return error_message
+
+
+class BadRequestException(ApiException):
+ pass
+
+
+class NotFoundException(ApiException):
+ pass
+
+
+class UnauthorizedException(ApiException):
+ pass
+
+
+class ForbiddenException(ApiException):
+ pass
+
+
+class ServiceException(ApiException):
+ pass
+
+
+def render_path(path_to_item):
+ """Returns a string representation of a path"""
+ result = ""
+ for pth in path_to_item:
+ if isinstance(pth, int):
+ result += "[{0}]".format(pth)
+ else:
+ result += "['{0}']".format(pth)
+ return result
diff --git a/scm/identity_services/models/__init__.py b/scm/identity_services/models/__init__.py
new file mode 100644
index 00000000..ea42a62d
--- /dev/null
+++ b/scm/identity_services/models/__init__.py
@@ -0,0 +1,91 @@
+# coding: utf-8
+
+# flake8: noqa
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+# import models into model package
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from scm.identity_services.models.authentication_portals_list_response import AuthenticationPortalsListResponse
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.models.authentication_profiles_list_response import AuthenticationProfilesListResponse
+from scm.identity_services.models.authentication_profiles_lockout import AuthenticationProfilesLockout
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+from scm.identity_services.models.authentication_profiles_method_cloud import AuthenticationProfilesMethodCloud
+from scm.identity_services.models.authentication_profiles_method_kerberos import AuthenticationProfilesMethodKerberos
+from scm.identity_services.models.authentication_profiles_method_ldap import AuthenticationProfilesMethodLdap
+from scm.identity_services.models.authentication_profiles_method_radius import AuthenticationProfilesMethodRadius
+from scm.identity_services.models.authentication_profiles_method_saml_idp import AuthenticationProfilesMethodSamlIdp
+from scm.identity_services.models.authentication_profiles_method_tacplus import AuthenticationProfilesMethodTacplus
+from scm.identity_services.models.authentication_profiles_multi_factor_auth import AuthenticationProfilesMultiFactorAuth
+from scm.identity_services.models.authentication_profiles_single_sign_on import AuthenticationProfilesSingleSignOn
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from scm.identity_services.models.authentication_rules_list_response import AuthenticationRulesListResponse
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from scm.identity_services.models.authentication_sequences_list_response import AuthenticationSequencesListResponse
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from scm.identity_services.models.certificate_profiles_ca_certificates_inner import CertificateProfilesCaCertificatesInner
+from scm.identity_services.models.certificate_profiles_list_response import CertificateProfilesListResponse
+from scm.identity_services.models.certificate_profiles_username_field import CertificateProfilesUsernameField
+from scm.identity_services.models.certificates_get import CertificatesGet
+from scm.identity_services.models.certificates_import import CertificatesImport
+from scm.identity_services.models.certificates_list_response import CertificatesListResponse
+from scm.identity_services.models.certificates_post import CertificatesPost
+from scm.identity_services.models.certificates_post_algorithm import CertificatesPostAlgorithm
+from scm.identity_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.identity_services.models.export_certificate_payload import ExportCertificatePayload
+from scm.identity_services.models.export_certificate_response import ExportCertificateResponse
+from scm.identity_services.models.generic_error import GenericError
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from scm.identity_services.models.kerberos_server_profiles_list_response import KerberosServerProfilesListResponse
+from scm.identity_services.models.kerberos_server_profiles_server_inner import KerberosServerProfilesServerInner
+from scm.identity_services.models.ldap_server_profiles_list_response import LDAPServerProfilesListResponse
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+from scm.identity_services.models.ldap_server_profiles_server_inner import LdapServerProfilesServerInner
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from scm.identity_services.models.local_user_groups_list_response import LocalUserGroupsListResponse
+from scm.identity_services.models.local_users import LocalUsers
+from scm.identity_services.models.local_users_list_response import LocalUsersListResponse
+from scm.identity_services.models.mfa_servers_list_response import MFAServersListResponse
+from scm.identity_services.models.mfa_servers import MfaServers
+from scm.identity_services.models.mfa_servers_mfa_vendor_type import MfaServersMfaVendorType
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_duo_security_v2 import MfaServersMfaVendorTypeDuoSecurityV2
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_okta_adaptive_v1 import MfaServersMfaVendorTypeOktaAdaptiveV1
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_ping_identity_v1 import MfaServersMfaVendorTypePingIdentityV1
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_rsa_securid_access_v1 import MfaServersMfaVendorTypeRsaSecuridAccessV1
+from scm.identity_services.models.ocsp_responders_list_response import OCSPRespondersListResponse
+from scm.identity_services.models.ocsp_responders import OcspResponders
+from scm.identity_services.models.radius_server_profiles_list_response import RADIUSServerProfilesListResponse
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+from scm.identity_services.models.radius_server_profiles_protocol import RadiusServerProfilesProtocol
+from scm.identity_services.models.radius_server_profiles_protocol_eapttls_with_pap import RadiusServerProfilesProtocolEAPTTLSWithPAP
+from scm.identity_services.models.radius_server_profiles_protocol_peapmschapv2 import RadiusServerProfilesProtocolPEAPMSCHAPv2
+from scm.identity_services.models.radius_server_profiles_server_inner import RadiusServerProfilesServerInner
+from scm.identity_services.models.rule_based_move import RuleBasedMove
+from scm.identity_services.models.saml_server_profiles_list_response import SAMLServerProfilesListResponse
+from scm.identity_services.models.scep_profiles_list_response import SCEPProfilesListResponse
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+from scm.identity_services.models.scep_profiles import ScepProfiles
+from scm.identity_services.models.scep_profiles_algorithm import ScepProfilesAlgorithm
+from scm.identity_services.models.scep_profiles_algorithm_rsa import ScepProfilesAlgorithmRsa
+from scm.identity_services.models.scep_profiles_certificate_attributes import ScepProfilesCertificateAttributes
+from scm.identity_services.models.scep_profiles_scep_challenge import ScepProfilesScepChallenge
+from scm.identity_services.models.scep_profiles_scep_challenge_dynamic import ScepProfilesScepChallengeDynamic
+from scm.identity_services.models.tacacs_server_profiles_list_response import TACACSServerProfilesListResponse
+from scm.identity_services.models.tls_service_profiles_list_response import TLSServiceProfilesListResponse
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+from scm.identity_services.models.tacacs_server_profiles_server_inner import TacacsServerProfilesServerInner
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+from scm.identity_services.models.tls_service_profiles_protocol_settings import TlsServiceProfilesProtocolSettings
+from scm.identity_services.models.trusted_certificate_authorities import TrustedCertificateAuthorities
+from scm.identity_services.models.trusted_certificate_authorities_list_response import TrustedCertificateAuthoritiesListResponse
diff --git a/scm/identity_services/models/authentication_portals.py b/scm/identity_services/models/authentication_portals.py
new file mode 100644
index 00000000..1a18f6f2
--- /dev/null
+++ b/scm/identity_services/models/authentication_portals.py
@@ -0,0 +1,141 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationPortals(BaseModel):
+ """
+ AuthenticationPortals
+ """ # noqa: E501
+ authentication_profile: Optional[StrictStr] = Field(default=None, description="The authentication profile")
+ certificate_profile: Optional[StrictStr] = Field(default=None, description="The certificate profile")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ gp_udp_port: Optional[Annotated[int, Field(le=65535, strict=True, ge=1)]] = Field(default=None, description="The UDP port for inbound authentication prompts")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the authentication portal")
+ idle_timer: Optional[Annotated[int, Field(le=1440, strict=True, ge=1)]] = Field(default=None, description="The idle timeout value (minutes)")
+ redirect_host: StrictStr = Field(description="The authentication portal IP address or hostname")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ timer: Optional[Annotated[int, Field(le=1440, strict=True, ge=1)]] = None
+ tls_service_profile: Optional[StrictStr] = Field(default=None, description="The SSL/TLS service profile")
+ __properties: ClassVar[List[str]] = ["authentication_profile", "certificate_profile", "device", "folder", "gp_udp_port", "id", "idle_timer", "redirect_host", "snippet", "timer", "tls_service_profile"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationPortals from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationPortals from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authentication_profile": obj.get("authentication_profile"),
+ "certificate_profile": obj.get("certificate_profile"),
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "gp_udp_port": obj.get("gp_udp_port"),
+ "id": obj.get("id"),
+ "idle_timer": obj.get("idle_timer"),
+ "redirect_host": obj.get("redirect_host"),
+ "snippet": obj.get("snippet"),
+ "timer": obj.get("timer"),
+ "tls_service_profile": obj.get("tls_service_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_portals_list_response.py b/scm/identity_services/models/authentication_portals_list_response.py
new file mode 100644
index 00000000..74afa356
--- /dev/null
+++ b/scm/identity_services/models/authentication_portals_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationPortalsListResponse(BaseModel):
+ """
+ AuthenticationPortalsListResponse
+ """ # noqa: E501
+ data: List[AuthenticationPortals]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationPortalsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationPortalsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = AuthenticationPortals.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [AuthenticationPortals.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles.py b/scm/identity_services/models/authentication_profiles.py
new file mode 100644
index 00000000..cb7f9d64
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles.py
@@ -0,0 +1,169 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.authentication_profiles_lockout import AuthenticationProfilesLockout
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+from scm.identity_services.models.authentication_profiles_multi_factor_auth import AuthenticationProfilesMultiFactorAuth
+from scm.identity_services.models.authentication_profiles_single_sign_on import AuthenticationProfilesSingleSignOn
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfiles(BaseModel):
+ """
+ AuthenticationProfiles
+ """ # noqa: E501
+ allow_list: Optional[List[StrictStr]] = Field(default=None, description="The allow_list of the authentication profile")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the authentication profile")
+ lockout: Optional[AuthenticationProfilesLockout] = None
+ method: Optional[AuthenticationProfilesMethod] = None
+ multi_factor_auth: Optional[AuthenticationProfilesMultiFactorAuth] = None
+ name: StrictStr = Field(description="The name of the authentication profile")
+ single_sign_on: Optional[AuthenticationProfilesSingleSignOn] = None
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ user_domain: Optional[Annotated[str, Field(strict=True, max_length=63)]] = None
+ username_modifier: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["allow_list", "device", "folder", "id", "lockout", "method", "multi_factor_auth", "name", "single_sign_on", "snippet", "user_domain", "username_modifier"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('username_modifier')
+ def username_modifier_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['%USERINPUT%', '%USERINPUT%@%USERDOMAIN%', '%USERDOMAIN%\\\\%USERINPUT%']):
+ raise ValueError("must be one of enum values ('%USERINPUT%', '%USERINPUT%@%USERDOMAIN%', '%USERDOMAIN%\\\\%USERINPUT%')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of lockout
+ if self.lockout:
+ _dict['lockout'] = self.lockout.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of method
+ if self.method:
+ _dict['method'] = self.method.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of multi_factor_auth
+ if self.multi_factor_auth:
+ _dict['multi_factor_auth'] = self.multi_factor_auth.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of single_sign_on
+ if self.single_sign_on:
+ _dict['single_sign_on'] = self.single_sign_on.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "allow_list": obj.get("allow_list"),
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "lockout": AuthenticationProfilesLockout.from_dict(obj["lockout"]) if obj.get("lockout") is not None else None,
+ "method": AuthenticationProfilesMethod.from_dict(obj["method"]) if obj.get("method") is not None else None,
+ "multi_factor_auth": AuthenticationProfilesMultiFactorAuth.from_dict(obj["multi_factor_auth"]) if obj.get("multi_factor_auth") is not None else None,
+ "name": obj.get("name"),
+ "single_sign_on": AuthenticationProfilesSingleSignOn.from_dict(obj["single_sign_on"]) if obj.get("single_sign_on") is not None else None,
+ "snippet": obj.get("snippet"),
+ "user_domain": obj.get("user_domain"),
+ "username_modifier": obj.get("username_modifier")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_list_response.py b/scm/identity_services/models/authentication_profiles_list_response.py
new file mode 100644
index 00000000..b3d3e1df
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesListResponse(BaseModel):
+ """
+ AuthenticationProfilesListResponse
+ """ # noqa: E501
+ data: List[AuthenticationProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = AuthenticationProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [AuthenticationProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_lockout.py b/scm/identity_services/models/authentication_profiles_lockout.py
new file mode 100644
index 00000000..f337d460
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_lockout.py
@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesLockout(BaseModel):
+ """
+ Lockout object of the authentication profile
+ """ # noqa: E501
+ failed_attempts: Optional[Annotated[int, Field(le=10, strict=True, ge=0)]] = Field(default=None, description="Lockout object - failed_attempts of authentication profile")
+ lockout_time: Optional[Annotated[int, Field(le=60, strict=True, ge=0)]] = Field(default=None, description="Lockout object - lockout-time of authentication profile")
+ __properties: ClassVar[List[str]] = ["failed_attempts", "lockout_time"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesLockout from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesLockout from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "failed_attempts": obj.get("failed_attempts"),
+ "lockout_time": obj.get("lockout_time")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_method.py b/scm/identity_services/models/authentication_profiles_method.py
new file mode 100644
index 00000000..def6bdb7
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_method.py
@@ -0,0 +1,124 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.identity_services.models.authentication_profiles_method_cloud import AuthenticationProfilesMethodCloud
+from scm.identity_services.models.authentication_profiles_method_kerberos import AuthenticationProfilesMethodKerberos
+from scm.identity_services.models.authentication_profiles_method_ldap import AuthenticationProfilesMethodLdap
+from scm.identity_services.models.authentication_profiles_method_radius import AuthenticationProfilesMethodRadius
+from scm.identity_services.models.authentication_profiles_method_saml_idp import AuthenticationProfilesMethodSamlIdp
+from scm.identity_services.models.authentication_profiles_method_tacplus import AuthenticationProfilesMethodTacplus
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMethod(BaseModel):
+ """
+ method object of authentication profile
+ """ # noqa: E501
+ cloud: Optional[AuthenticationProfilesMethodCloud] = None
+ kerberos: Optional[AuthenticationProfilesMethodKerberos] = None
+ ldap: Optional[AuthenticationProfilesMethodLdap] = None
+ local_database: Optional[Dict[str, Any]] = None
+ radius: Optional[AuthenticationProfilesMethodRadius] = None
+ saml_idp: Optional[AuthenticationProfilesMethodSamlIdp] = None
+ tacplus: Optional[AuthenticationProfilesMethodTacplus] = None
+ __properties: ClassVar[List[str]] = ["cloud", "kerberos", "ldap", "local_database", "radius", "saml_idp", "tacplus"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethod from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of cloud
+ if self.cloud:
+ _dict['cloud'] = self.cloud.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of kerberos
+ if self.kerberos:
+ _dict['kerberos'] = self.kerberos.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of ldap
+ if self.ldap:
+ _dict['ldap'] = self.ldap.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of radius
+ if self.radius:
+ _dict['radius'] = self.radius.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of saml_idp
+ if self.saml_idp:
+ _dict['saml_idp'] = self.saml_idp.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of tacplus
+ if self.tacplus:
+ _dict['tacplus'] = self.tacplus.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethod from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "cloud": AuthenticationProfilesMethodCloud.from_dict(obj["cloud"]) if obj.get("cloud") is not None else None,
+ "kerberos": AuthenticationProfilesMethodKerberos.from_dict(obj["kerberos"]) if obj.get("kerberos") is not None else None,
+ "ldap": AuthenticationProfilesMethodLdap.from_dict(obj["ldap"]) if obj.get("ldap") is not None else None,
+ "local_database": obj.get("local_database"),
+ "radius": AuthenticationProfilesMethodRadius.from_dict(obj["radius"]) if obj.get("radius") is not None else None,
+ "saml_idp": AuthenticationProfilesMethodSamlIdp.from_dict(obj["saml_idp"]) if obj.get("saml_idp") is not None else None,
+ "tacplus": AuthenticationProfilesMethodTacplus.from_dict(obj["tacplus"]) if obj.get("tacplus") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_method_cloud.py b/scm/identity_services/models/authentication_profiles_method_cloud.py
new file mode 100644
index 00000000..3240898c
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_method_cloud.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMethodCloud(BaseModel):
+ """
+ AuthenticationProfilesMethodCloud
+ """ # noqa: E501
+ profile_name: Optional[StrictStr] = Field(default=None, description="The tenant profile name")
+ __properties: ClassVar[List[str]] = ["profile_name"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodCloud from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodCloud from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "profile_name": obj.get("profile_name")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_method_kerberos.py b/scm/identity_services/models/authentication_profiles_method_kerberos.py
new file mode 100644
index 00000000..111ba42c
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_method_kerberos.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMethodKerberos(BaseModel):
+ """
+ AuthenticationProfilesMethodKerberos
+ """ # noqa: E501
+ realm: Optional[StrictStr] = Field(default=None, description="method kerberos object realm of authentication profile")
+ server_profile: Optional[StrictStr] = Field(default=None, description="method kerberos object server profile of authentication profile")
+ __properties: ClassVar[List[str]] = ["realm", "server_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodKerberos from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodKerberos from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "realm": obj.get("realm"),
+ "server_profile": obj.get("server_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_method_ldap.py b/scm/identity_services/models/authentication_profiles_method_ldap.py
new file mode 100644
index 00000000..8f23efcc
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_method_ldap.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMethodLdap(BaseModel):
+ """
+ AuthenticationProfilesMethodLdap
+ """ # noqa: E501
+ login_attribute: Optional[StrictStr] = None
+ passwd_exp_days: Optional[StrictInt] = None
+ server_profile: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["login_attribute", "passwd_exp_days", "server_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodLdap from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodLdap from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "login_attribute": obj.get("login_attribute"),
+ "passwd_exp_days": obj.get("passwd_exp_days"),
+ "server_profile": obj.get("server_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_method_radius.py b/scm/identity_services/models/authentication_profiles_method_radius.py
new file mode 100644
index 00000000..d884891f
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_method_radius.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMethodRadius(BaseModel):
+ """
+ AuthenticationProfilesMethodRadius
+ """ # noqa: E501
+ checkgroup: Optional[StrictBool] = Field(default=None, description="method radius object check group of authentication profile")
+ server_profile: Optional[StrictStr] = Field(default=None, description="method radius object server profile of authentication profile")
+ __properties: ClassVar[List[str]] = ["checkgroup", "server_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodRadius from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodRadius from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "checkgroup": obj.get("checkgroup"),
+ "server_profile": obj.get("server_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_method_saml_idp.py b/scm/identity_services/models/authentication_profiles_method_saml_idp.py
new file mode 100644
index 00000000..b407a5d9
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_method_saml_idp.py
@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMethodSamlIdp(BaseModel):
+ """
+ AuthenticationProfilesMethodSamlIdp
+ """ # noqa: E501
+ attribute_name_usergroup: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=63)]] = None
+ attribute_name_username: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=63)]] = None
+ certificate_profile: Optional[Annotated[str, Field(strict=True, max_length=31)]] = Field(default=None, description="method object saml idp certificate profile of authentication profile")
+ enable_single_logout: Optional[StrictBool] = None
+ request_signing_certificate: Optional[Annotated[str, Field(strict=True, max_length=64)]] = None
+ server_profile: Optional[Annotated[str, Field(strict=True, max_length=63)]] = Field(default=None, description="method object saml idp server profile of authentication profile")
+ __properties: ClassVar[List[str]] = ["attribute_name_usergroup", "attribute_name_username", "certificate_profile", "enable_single_logout", "request_signing_certificate", "server_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodSamlIdp from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodSamlIdp from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "attribute_name_usergroup": obj.get("attribute_name_usergroup"),
+ "attribute_name_username": obj.get("attribute_name_username"),
+ "certificate_profile": obj.get("certificate_profile"),
+ "enable_single_logout": obj.get("enable_single_logout"),
+ "request_signing_certificate": obj.get("request_signing_certificate"),
+ "server_profile": obj.get("server_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_method_tacplus.py b/scm/identity_services/models/authentication_profiles_method_tacplus.py
new file mode 100644
index 00000000..2647b666
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_method_tacplus.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMethodTacplus(BaseModel):
+ """
+ AuthenticationProfilesMethodTacplus
+ """ # noqa: E501
+ checkgroup: Optional[StrictBool] = Field(default=None, description="method tacplus object check group of authentication profile")
+ server_profile: Optional[StrictStr] = Field(default=None, description="method tacplus object check group of authentication profile")
+ __properties: ClassVar[List[str]] = ["checkgroup", "server_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodTacplus from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMethodTacplus from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "checkgroup": obj.get("checkgroup"),
+ "server_profile": obj.get("server_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_multi_factor_auth.py b/scm/identity_services/models/authentication_profiles_multi_factor_auth.py
new file mode 100644
index 00000000..a5f39fa1
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_multi_factor_auth.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesMultiFactorAuth(BaseModel):
+ """
+ AuthenticationProfilesMultiFactorAuth
+ """ # noqa: E501
+ factors: Optional[List[StrictStr]] = None
+ mfa_enable: Optional[StrictBool] = None
+ __properties: ClassVar[List[str]] = ["factors", "mfa_enable"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMultiFactorAuth from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesMultiFactorAuth from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "factors": obj.get("factors"),
+ "mfa_enable": obj.get("mfa_enable")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_profiles_single_sign_on.py b/scm/identity_services/models/authentication_profiles_single_sign_on.py
new file mode 100644
index 00000000..6fcea7bf
--- /dev/null
+++ b/scm/identity_services/models/authentication_profiles_single_sign_on.py
@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationProfilesSingleSignOn(BaseModel):
+ """
+ AuthenticationProfilesSingleSignOn
+ """ # noqa: E501
+ kerberos_keytab: Optional[Annotated[str, Field(strict=True, max_length=8192)]] = None
+ realm: Optional[Annotated[str, Field(strict=True, max_length=127)]] = None
+ __properties: ClassVar[List[str]] = ["kerberos_keytab", "realm"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesSingleSignOn from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationProfilesSingleSignOn from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "kerberos_keytab": obj.get("kerberos_keytab"),
+ "realm": obj.get("realm")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_rules.py b/scm/identity_services/models/authentication_rules.py
new file mode 100644
index 00000000..1612578e
--- /dev/null
+++ b/scm/identity_services/models/authentication_rules.py
@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationRules(BaseModel):
+ """
+ AuthenticationRules
+ """ # noqa: E501
+ authentication_enforcement: Optional[StrictStr] = Field(default=None, description="The authentication profile name")
+ category: Optional[List[StrictStr]] = Field(default=None, description="The destination URL categories")
+ description: Optional[StrictStr] = Field(default=None, description="The description of the authentication rule")
+ destination: List[StrictStr] = Field(description="The destination addresses")
+ destination_hip: Optional[List[StrictStr]] = Field(default=None, description="The destination Host Integrity Profile (HIP)")
+ device: Optional[StrictStr] = None
+ disabled: Optional[StrictBool] = Field(default=False, description="Is the authentication rule disabled?")
+ folder: Optional[StrictStr] = None
+ var_from: List[StrictStr] = Field(description="The source security zones", alias="from")
+ group_tag: Optional[StrictStr] = None
+ hip_profiles: Optional[List[StrictStr]] = Field(default=None, description="The source Host Integrity Profile (HIP)")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the authentication rule")
+ log_authentication_timeout: Optional[StrictBool] = Field(default=False, description="Log authentication timeouts?")
+ log_setting: Optional[StrictStr] = Field(default=None, description="The log forwarding profile name")
+ name: StrictStr = Field(description="The name of the authentication rule")
+ negate_destination: Optional[StrictBool] = Field(default=False, description="Are the destination addresses negated?")
+ negate_source: Optional[StrictBool] = Field(default=False, description="Are the source addresses negated?")
+ service: List[StrictStr] = Field(description="The destination ports")
+ snippet: Optional[StrictStr] = None
+ source: List[StrictStr] = Field(description="The source addresses")
+ source_hip: Optional[List[StrictStr]] = Field(default=None, description="The source Host Integrity Profile (HIP)")
+ source_user: Optional[List[StrictStr]] = Field(default=None, description="The source users")
+ tag: Optional[List[StrictStr]] = Field(default=None, description="The authentication rule tags")
+ timeout: Optional[Annotated[int, Field(le=1440, strict=True, ge=1)]] = Field(default=None, description="The authentication session timeout (seconds)")
+ to: List[StrictStr] = Field(description="The destination security zones")
+ __properties: ClassVar[List[str]] = ["authentication_enforcement", "category", "description", "destination", "destination_hip", "device", "disabled", "folder", "from", "group_tag", "hip_profiles", "id", "log_authentication_timeout", "log_setting", "name", "negate_destination", "negate_source", "service", "snippet", "source", "source_hip", "source_user", "tag", "timeout", "to"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationRules from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationRules from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authentication_enforcement": obj.get("authentication_enforcement"),
+ "category": obj.get("category"),
+ "description": obj.get("description"),
+ "destination": obj.get("destination"),
+ "destination_hip": obj.get("destination_hip"),
+ "device": obj.get("device"),
+ "disabled": obj.get("disabled") if obj.get("disabled") is not None else False,
+ "folder": obj.get("folder"),
+ "from": obj.get("from"),
+ "group_tag": obj.get("group_tag"),
+ "hip_profiles": obj.get("hip_profiles"),
+ "id": obj.get("id"),
+ "log_authentication_timeout": obj.get("log_authentication_timeout") if obj.get("log_authentication_timeout") is not None else False,
+ "log_setting": obj.get("log_setting"),
+ "name": obj.get("name"),
+ "negate_destination": obj.get("negate_destination") if obj.get("negate_destination") is not None else False,
+ "negate_source": obj.get("negate_source") if obj.get("negate_source") is not None else False,
+ "service": obj.get("service"),
+ "snippet": obj.get("snippet"),
+ "source": obj.get("source"),
+ "source_hip": obj.get("source_hip"),
+ "source_user": obj.get("source_user"),
+ "tag": obj.get("tag"),
+ "timeout": obj.get("timeout"),
+ "to": obj.get("to")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_rules_list_response.py b/scm/identity_services/models/authentication_rules_list_response.py
new file mode 100644
index 00000000..3f902378
--- /dev/null
+++ b/scm/identity_services/models/authentication_rules_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationRulesListResponse(BaseModel):
+ """
+ AuthenticationRulesListResponse
+ """ # noqa: E501
+ data: List[AuthenticationRules]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationRulesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationRulesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = AuthenticationRules.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [AuthenticationRules.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_sequences.py b/scm/identity_services/models/authentication_sequences.py
new file mode 100644
index 00000000..2e8678d8
--- /dev/null
+++ b/scm/identity_services/models/authentication_sequences.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationSequences(BaseModel):
+ """
+ AuthenticationSequences
+ """ # noqa: E501
+ authentication_profiles: Optional[List[StrictStr]] = Field(default=None, description="An ordered list of authentication profiles")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the authentication sequence")
+ name: StrictStr = Field(description="The name of the authentication sequence")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ use_domain_find_profile: Optional[StrictBool] = Field(default=True, description="Use domain to determine authentication profile?")
+ __properties: ClassVar[List[str]] = ["authentication_profiles", "device", "folder", "id", "name", "snippet", "use_domain_find_profile"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationSequences from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationSequences from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "authentication_profiles": obj.get("authentication_profiles"),
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "snippet": obj.get("snippet"),
+ "use_domain_find_profile": obj.get("use_domain_find_profile") if obj.get("use_domain_find_profile") is not None else True
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/authentication_sequences_list_response.py b/scm/identity_services/models/authentication_sequences_list_response.py
new file mode 100644
index 00000000..3118b64e
--- /dev/null
+++ b/scm/identity_services/models/authentication_sequences_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from typing import Optional, Set
+from typing_extensions import Self
+
+class AuthenticationSequencesListResponse(BaseModel):
+ """
+ AuthenticationSequencesListResponse
+ """ # noqa: E501
+ data: List[AuthenticationSequences]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of AuthenticationSequencesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of AuthenticationSequencesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = AuthenticationSequences.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [AuthenticationSequences.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificate_profiles.py b/scm/identity_services/models/certificate_profiles.py
new file mode 100644
index 00000000..dec17b04
--- /dev/null
+++ b/scm/identity_services/models/certificate_profiles.py
@@ -0,0 +1,165 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.certificate_profiles_ca_certificates_inner import CertificateProfilesCaCertificatesInner
+from scm.identity_services.models.certificate_profiles_username_field import CertificateProfilesUsernameField
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificateProfiles(BaseModel):
+ """
+ CertificateProfiles
+ """ # noqa: E501
+ block_expired_cert: Optional[StrictBool] = Field(default=None, description="Block sessions with expired certificates?")
+ block_timeout_cert: Optional[StrictBool] = Field(default=None, description="Block session if certificate status cannot be retrieved within timeout?")
+ block_unauthenticated_cert: Optional[StrictBool] = Field(default=None, description="Block session if the certificate was not issued to the authenticating device?")
+ block_unknown_cert: Optional[StrictBool] = Field(default=None, description="Block session if certificate status is unknown?")
+ ca_certificates: List[CertificateProfilesCaCertificatesInner] = Field(description="An ordered list of CA certificates")
+ cert_status_timeout: Optional[StrictStr] = Field(default=None, description="Certificate status timeout")
+ crl_receive_timeout: Optional[StrictStr] = Field(default=None, description="CRL receive timeout (seconds)")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ domain: Optional[StrictStr] = Field(default=None, description="User domain")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the certificate profile")
+ name: Annotated[str, Field(strict=True, max_length=63)] = Field(description="The name of the certificate profile")
+ ocsp_receive_timeout: Optional[StrictStr] = Field(default=None, description="OCSP receive timeout (seconds)")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ use_crl: Optional[StrictBool] = Field(default=None, description="Use CRL?")
+ use_ocsp: Optional[StrictBool] = Field(default=None, description="Use OCSP?")
+ username_field: Optional[CertificateProfilesUsernameField] = None
+ __properties: ClassVar[List[str]] = ["block_expired_cert", "block_timeout_cert", "block_unauthenticated_cert", "block_unknown_cert", "ca_certificates", "cert_status_timeout", "crl_receive_timeout", "device", "domain", "folder", "id", "name", "ocsp_receive_timeout", "snippet", "use_crl", "use_ocsp", "username_field"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificateProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in ca_certificates (list)
+ _items = []
+ if self.ca_certificates:
+ for _item_ca_certificates in self.ca_certificates:
+ if _item_ca_certificates:
+ _items.append(_item_ca_certificates.to_dict())
+ _dict['ca_certificates'] = _items
+ # override the default output from pydantic by calling `to_dict()` of username_field
+ if self.username_field:
+ _dict['username_field'] = self.username_field.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificateProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "block_expired_cert": obj.get("block_expired_cert"),
+ "block_timeout_cert": obj.get("block_timeout_cert"),
+ "block_unauthenticated_cert": obj.get("block_unauthenticated_cert"),
+ "block_unknown_cert": obj.get("block_unknown_cert"),
+ "ca_certificates": [CertificateProfilesCaCertificatesInner.from_dict(_item) for _item in obj["ca_certificates"]] if obj.get("ca_certificates") is not None else None,
+ "cert_status_timeout": obj.get("cert_status_timeout"),
+ "crl_receive_timeout": obj.get("crl_receive_timeout"),
+ "device": obj.get("device"),
+ "domain": obj.get("domain"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "ocsp_receive_timeout": obj.get("ocsp_receive_timeout"),
+ "snippet": obj.get("snippet"),
+ "use_crl": obj.get("use_crl"),
+ "use_ocsp": obj.get("use_ocsp"),
+ "username_field": CertificateProfilesUsernameField.from_dict(obj["username_field"]) if obj.get("username_field") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificate_profiles_ca_certificates_inner.py b/scm/identity_services/models/certificate_profiles_ca_certificates_inner.py
new file mode 100644
index 00000000..06c1f4ca
--- /dev/null
+++ b/scm/identity_services/models/certificate_profiles_ca_certificates_inner.py
@@ -0,0 +1,94 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificateProfilesCaCertificatesInner(BaseModel):
+ """
+ CA certificate
+ """ # noqa: E501
+ default_ocsp_url: Optional[StrictStr] = Field(default=None, description="Default OCSP URL")
+ name: StrictStr = Field(description="CA certificate name")
+ ocsp_verify_cert: Optional[StrictStr] = Field(default=None, description="OCSP verify certificate")
+ template_name: Optional[StrictStr] = Field(default=None, description="Template name/OID")
+ __properties: ClassVar[List[str]] = ["default_ocsp_url", "name", "ocsp_verify_cert", "template_name"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificateProfilesCaCertificatesInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificateProfilesCaCertificatesInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "default_ocsp_url": obj.get("default_ocsp_url"),
+ "name": obj.get("name"),
+ "ocsp_verify_cert": obj.get("ocsp_verify_cert"),
+ "template_name": obj.get("template_name")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificate_profiles_list_response.py b/scm/identity_services/models/certificate_profiles_list_response.py
new file mode 100644
index 00000000..94cbd8bd
--- /dev/null
+++ b/scm/identity_services/models/certificate_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificateProfilesListResponse(BaseModel):
+ """
+ CertificateProfilesListResponse
+ """ # noqa: E501
+ data: List[CertificateProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificateProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificateProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = CertificateProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [CertificateProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificate_profiles_username_field.py b/scm/identity_services/models/certificate_profiles_username_field.py
new file mode 100644
index 00000000..31309425
--- /dev/null
+++ b/scm/identity_services/models/certificate_profiles_username_field.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificateProfilesUsernameField(BaseModel):
+ """
+ Certificate username field
+ """ # noqa: E501
+ subject: Optional[StrictStr] = Field(default=None, description="Common name")
+ subject_alt: Optional[StrictStr] = Field(default=None, description="Email address")
+ __properties: ClassVar[List[str]] = ["subject", "subject_alt"]
+
+ @field_validator('subject')
+ def subject_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['common-name']):
+ raise ValueError("must be one of enum values ('common-name')")
+ return value
+
+ @field_validator('subject_alt')
+ def subject_alt_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['email']):
+ raise ValueError("must be one of enum values ('email')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificateProfilesUsernameField from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificateProfilesUsernameField from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "subject": obj.get("subject"),
+ "subject_alt": obj.get("subject_alt")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificates_get.py b/scm/identity_services/models/certificates_get.py
new file mode 100644
index 00000000..25eb2c8e
--- /dev/null
+++ b/scm/identity_services/models/certificates_get.py
@@ -0,0 +1,156 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from datetime import date
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificatesGet(BaseModel):
+ """
+ CertificatesGet
+ """ # noqa: E501
+ algorithm: Optional[StrictStr] = Field(default=None, description="Algorithm")
+ ca: Optional[StrictBool] = Field(default=None, description="CA certificate?")
+ common_name: Optional[StrictStr] = Field(default=None, description="Common name")
+ common_name_int: Optional[StrictStr] = None
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ expiry_epoch: Optional[StrictStr] = None
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the certificate")
+ issuer: Optional[StrictStr] = Field(default=None, description="Issuer")
+ issuer_hash: Optional[StrictStr] = Field(default=None, description="Issue hash")
+ name: Optional[StrictStr] = Field(default=None, description="The name of the certificate")
+ not_valid_after: Optional[date] = Field(default=None, description="Not valid after this date")
+ not_valid_before: Optional[date] = Field(default=None, description="Not valid before this date")
+ public_key: Optional[StrictStr] = Field(default=None, description="Public key")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ subject: Optional[StrictStr] = Field(default=None, description="Subject")
+ subject_hash: Optional[StrictStr] = Field(default=None, description="Subject hash")
+ subject_int: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["algorithm", "ca", "common_name", "common_name_int", "device", "expiry_epoch", "folder", "id", "issuer", "issuer_hash", "name", "not_valid_after", "not_valid_before", "public_key", "snippet", "subject", "subject_hash", "subject_int"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificatesGet from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificatesGet from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "algorithm": obj.get("algorithm"),
+ "ca": obj.get("ca"),
+ "common_name": obj.get("common_name"),
+ "common_name_int": obj.get("common_name_int"),
+ "device": obj.get("device"),
+ "expiry_epoch": obj.get("expiry_epoch"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "issuer": obj.get("issuer"),
+ "issuer_hash": obj.get("issuer_hash"),
+ "name": obj.get("name"),
+ "not_valid_after": obj.get("not_valid_after"),
+ "not_valid_before": obj.get("not_valid_before"),
+ "public_key": obj.get("public_key"),
+ "snippet": obj.get("snippet"),
+ "subject": obj.get("subject"),
+ "subject_hash": obj.get("subject_hash"),
+ "subject_int": obj.get("subject_int")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificates_import.py b/scm/identity_services/models/certificates_import.py
new file mode 100644
index 00000000..d29a3e4e
--- /dev/null
+++ b/scm/identity_services/models/certificates_import.py
@@ -0,0 +1,140 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificatesImport(BaseModel):
+ """
+ CertificatesImport
+ """ # noqa: E501
+ certificate_file: StrictStr = Field(description="The Base64 encoded content of the certificate public key")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ format: StrictStr = Field(description="Certificate format")
+ key_file: Optional[StrictStr] = Field(default=None, description="The Base64 encoded content of the certificate private key")
+ name: Annotated[str, Field(min_length=1, strict=True)] = Field(description="The name of the certificate")
+ passphrase: Optional[SecretStr] = Field(default=None, description="Passphrase to protect the certificate private key")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["certificate_file", "device", "folder", "format", "key_file", "name", "passphrase", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('format')
+ def format_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['pem', 'pkcs12', 'der']):
+ raise ValueError("must be one of enum values ('pem', 'pkcs12', 'der')")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificatesImport from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificatesImport from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "certificate_file": obj.get("certificate_file"),
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "format": obj.get("format") if obj.get("format") is not None else 'pem',
+ "key_file": obj.get("key_file"),
+ "name": obj.get("name"),
+ "passphrase": obj.get("passphrase"),
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificates_list_response.py b/scm/identity_services/models/certificates_list_response.py
new file mode 100644
index 00000000..cb6cb233
--- /dev/null
+++ b/scm/identity_services/models/certificates_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.certificates_get import CertificatesGet
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificatesListResponse(BaseModel):
+ """
+ CertificatesListResponse
+ """ # noqa: E501
+ data: List[CertificatesGet]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificatesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificatesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = CertificatesGet.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [CertificatesGet.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificates_post.py b/scm/identity_services/models/certificates_post.py
new file mode 100644
index 00000000..551bcfe2
--- /dev/null
+++ b/scm/identity_services/models/certificates_post.py
@@ -0,0 +1,168 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.certificates_post_algorithm import CertificatesPostAlgorithm
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificatesPost(BaseModel):
+ """
+ CertificatesPost
+ """ # noqa: E501
+ algorithm: CertificatesPostAlgorithm
+ alternate_email: Optional[List[StrictStr]] = Field(default=None, description="Alternate email")
+ certificate_name: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Certificate name")
+ common_name: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Common name")
+ country_code: Optional[StrictStr] = Field(default=None, description="Country code")
+ day_till_expiration: Optional[StrictInt] = Field(default=None, description="Expiration (days)")
+ department: Optional[List[StrictStr]] = Field(default=None, description="Department")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ digest: StrictStr = Field(description="Hash algorithm")
+ email: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="Email")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ hostname: Optional[List[Annotated[str, Field(min_length=1, strict=True, max_length=64)]]] = Field(default=None, description="Hostname")
+ ip: Optional[List[Annotated[str, Field(min_length=1, strict=True, max_length=64)]]] = Field(default=None, description="IP address")
+ is_block_private_key: Optional[StrictBool] = Field(default=None, description="Block private key export?", alias="is_block_privateKey")
+ is_certificate_authority: Optional[StrictBool] = Field(default=None, description="Certificate authority certificate?")
+ locality: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="Locality")
+ ocsp_responder_url: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="OCSP responder URL")
+ signed_by: Annotated[str, Field(strict=True, max_length=64)] = Field(description="Signed by")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ state: Optional[Annotated[str, Field(strict=True, max_length=32)]] = Field(default=None, description="State")
+ __properties: ClassVar[List[str]] = ["algorithm", "alternate_email", "certificate_name", "common_name", "country_code", "day_till_expiration", "department", "device", "digest", "email", "folder", "hostname", "ip", "is_block_privateKey", "is_certificate_authority", "locality", "ocsp_responder_url", "signed_by", "snippet", "state"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('digest')
+ def digest_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['sha1', 'sha256', 'sha384', 'sha512', 'md5']):
+ raise ValueError("must be one of enum values ('sha1', 'sha256', 'sha384', 'sha512', 'md5')")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificatesPost from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of algorithm
+ if self.algorithm:
+ _dict['algorithm'] = self.algorithm.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificatesPost from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "algorithm": CertificatesPostAlgorithm.from_dict(obj["algorithm"]) if obj.get("algorithm") is not None else None,
+ "alternate_email": obj.get("alternate_email"),
+ "certificate_name": obj.get("certificate_name"),
+ "common_name": obj.get("common_name"),
+ "country_code": obj.get("country_code"),
+ "day_till_expiration": obj.get("day_till_expiration"),
+ "department": obj.get("department"),
+ "device": obj.get("device"),
+ "digest": obj.get("digest"),
+ "email": obj.get("email"),
+ "folder": obj.get("folder"),
+ "hostname": obj.get("hostname"),
+ "ip": obj.get("ip"),
+ "is_block_privateKey": obj.get("is_block_privateKey"),
+ "is_certificate_authority": obj.get("is_certificate_authority"),
+ "locality": obj.get("locality"),
+ "ocsp_responder_url": obj.get("ocsp_responder_url"),
+ "signed_by": obj.get("signed_by"),
+ "snippet": obj.get("snippet"),
+ "state": obj.get("state")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/certificates_post_algorithm.py b/scm/identity_services/models/certificates_post_algorithm.py
new file mode 100644
index 00000000..64eeb66c
--- /dev/null
+++ b/scm/identity_services/models/certificates_post_algorithm.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class CertificatesPostAlgorithm(BaseModel):
+ """
+ Encryption algorithm
+ """ # noqa: E501
+ ecdsa_number_of_bits: Optional[Union[StrictFloat, StrictInt]] = None
+ rsa_number_of_bits: Optional[Union[StrictFloat, StrictInt]] = None
+ __properties: ClassVar[List[str]] = ["ecdsa_number_of_bits", "rsa_number_of_bits"]
+
+ @field_validator('ecdsa_number_of_bits')
+ def ecdsa_number_of_bits_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set([245, 384, 2048, 3072, 4096]):
+ raise ValueError("must be one of enum values (245, 384, 2048, 3072, 4096)")
+ return value
+
+ @field_validator('rsa_number_of_bits')
+ def rsa_number_of_bits_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set([512, 1024, 2048, 3072, 4096]):
+ raise ValueError("must be one of enum values (512, 1024, 2048, 3072, 4096)")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of CertificatesPostAlgorithm from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of CertificatesPostAlgorithm from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ecdsa_number_of_bits": obj.get("ecdsa_number_of_bits"),
+ "rsa_number_of_bits": obj.get("rsa_number_of_bits")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/error_detail_cause_info.py b/scm/identity_services/models/error_detail_cause_info.py
new file mode 100644
index 00000000..df4aaa2c
--- /dev/null
+++ b/scm/identity_services/models/error_detail_cause_info.py
@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ErrorDetailCauseInfo(BaseModel):
+ """
+ ErrorDetailCauseInfo
+ """ # noqa: E501
+ code: Optional[StrictStr] = None
+ details: Optional[Any] = None
+ help: Optional[StrictStr] = None
+ message: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["code", "details", "help", "message"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # set to None if details (nullable) is None
+ # and model_fields_set contains the field
+ if self.details is None and "details" in self.model_fields_set:
+ _dict['details'] = None
+
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ErrorDetailCauseInfo from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "code": obj.get("code"),
+ "details": obj.get("details"),
+ "help": obj.get("help"),
+ "message": obj.get("message")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/export_certificate_payload.py b/scm/identity_services/models/export_certificate_payload.py
new file mode 100644
index 00000000..acb571c5
--- /dev/null
+++ b/scm/identity_services/models/export_certificate_payload.py
@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ExportCertificatePayload(BaseModel):
+ """
+ ExportCertificatePayload
+ """ # noqa: E501
+ format: StrictStr
+ passphrase: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["format", "passphrase"]
+
+ @field_validator('passphrase')
+ def passphrase_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['pkcs12', 'pem', 'der', 'pkcs10']):
+ raise ValueError("must be one of enum values ('pkcs12', 'pem', 'der', 'pkcs10')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ExportCertificatePayload from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ExportCertificatePayload from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "format": obj.get("format"),
+ "passphrase": obj.get("passphrase")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/export_certificate_response.py b/scm/identity_services/models/export_certificate_response.py
new file mode 100644
index 00000000..7e9b4d81
--- /dev/null
+++ b/scm/identity_services/models/export_certificate_response.py
@@ -0,0 +1,88 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ExportCertificateResponse(BaseModel):
+ """
+ ExportCertificateResponse
+ """ # noqa: E501
+ certificate: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["certificate"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ExportCertificateResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ExportCertificateResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "certificate": obj.get("certificate")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/generic_error.py b/scm/identity_services/models/generic_error.py
new file mode 100644
index 00000000..4e743a6b
--- /dev/null
+++ b/scm/identity_services/models/generic_error.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.identity_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+from typing import Optional, Set
+from typing_extensions import Self
+
+class GenericError(BaseModel):
+ """
+ GenericError
+ """ # noqa: E501
+ errors: Optional[List[ErrorDetailCauseInfo]] = Field(default=None, alias="_errors")
+ request_id: Optional[StrictStr] = Field(default=None, alias="_request_id")
+ __properties: ClassVar[List[str]] = ["_errors", "_request_id"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of GenericError from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in errors (list)
+ _items = []
+ if self.errors:
+ for _item_errors in self.errors:
+ if _item_errors:
+ _items.append(_item_errors.to_dict())
+ _dict['_errors'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of GenericError from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "_errors": [ErrorDetailCauseInfo.from_dict(_item) for _item in obj["_errors"]] if obj.get("_errors") is not None else None,
+ "_request_id": obj.get("_request_id")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/kerberos_server_profiles.py b/scm/identity_services/models/kerberos_server_profiles.py
new file mode 100644
index 00000000..26d49996
--- /dev/null
+++ b/scm/identity_services/models/kerberos_server_profiles.py
@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.kerberos_server_profiles_server_inner import KerberosServerProfilesServerInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class KerberosServerProfiles(BaseModel):
+ """
+ KerberosServerProfiles
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the Kerberos server profile")
+ name: StrictStr = Field(description="The name of the Kerberos server profile")
+ server: List[KerberosServerProfilesServerInner] = Field(description="The Kerberos server configuration")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "name", "server", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of KerberosServerProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in server (list)
+ _items = []
+ if self.server:
+ for _item_server in self.server:
+ if _item_server:
+ _items.append(_item_server.to_dict())
+ _dict['server'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of KerberosServerProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "server": [KerberosServerProfilesServerInner.from_dict(_item) for _item in obj["server"]] if obj.get("server") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/kerberos_server_profiles_list_response.py b/scm/identity_services/models/kerberos_server_profiles_list_response.py
new file mode 100644
index 00000000..c2fb3c7e
--- /dev/null
+++ b/scm/identity_services/models/kerberos_server_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class KerberosServerProfilesListResponse(BaseModel):
+ """
+ KerberosServerProfilesListResponse
+ """ # noqa: E501
+ data: List[KerberosServerProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of KerberosServerProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of KerberosServerProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = KerberosServerProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [KerberosServerProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/kerberos_server_profiles_server_inner.py b/scm/identity_services/models/kerberos_server_profiles_server_inner.py
new file mode 100644
index 00000000..ef548922
--- /dev/null
+++ b/scm/identity_services/models/kerberos_server_profiles_server_inner.py
@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class KerberosServerProfilesServerInner(BaseModel):
+ """
+ KerberosServerProfilesServerInner
+ """ # noqa: E501
+ host: StrictStr = Field(description="The Kerberos server IP address")
+ name: StrictStr = Field(description="The Kerberos server name")
+ port: Optional[Annotated[int, Field(le=65535, strict=True, ge=1)]] = Field(default=None, description="The Kerberos server port")
+ __properties: ClassVar[List[str]] = ["host", "name", "port"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of KerberosServerProfilesServerInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of KerberosServerProfilesServerInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "host": obj.get("host"),
+ "name": obj.get("name"),
+ "port": obj.get("port")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/ldap_server_profiles.py b/scm/identity_services/models/ldap_server_profiles.py
new file mode 100644
index 00000000..1533ea0a
--- /dev/null
+++ b/scm/identity_services/models/ldap_server_profiles.py
@@ -0,0 +1,167 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.ldap_server_profiles_server_inner import LdapServerProfilesServerInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LdapServerProfiles(BaseModel):
+ """
+ LdapServerProfiles
+ """ # noqa: E501
+ base: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The base DN")
+ bind_dn: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The bind DN")
+ bind_password: Optional[Annotated[str, Field(strict=True, max_length=121)]] = Field(default=None, description="The bind password")
+ bind_timelimit: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The bind timeout (seconds)")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the LDAP server profile")
+ ldap_type: Optional[StrictStr] = Field(default=None, description="The LDAP server time")
+ name: StrictStr = Field(description="The name of the LDAP server profile")
+ retry_interval: Optional[Annotated[int, Field(le=3600, strict=True, ge=60)]] = Field(default=None, description="The search retry interval (seconds)")
+ server: List[LdapServerProfilesServerInner] = Field(description="The LDAP server configuration")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ ssl: Optional[StrictBool] = Field(default=None, description="Require SSL/TLS secured connection?")
+ timelimit: Optional[Annotated[int, Field(le=30, strict=True, ge=1)]] = Field(default=None, description="The search timeout (seconds)")
+ verify_server_certificate: Optional[StrictBool] = Field(default=None, description="Verify server certificate for SSL sessions?")
+ __properties: ClassVar[List[str]] = ["base", "bind_dn", "bind_password", "bind_timelimit", "device", "folder", "id", "ldap_type", "name", "retry_interval", "server", "snippet", "ssl", "timelimit", "verify_server_certificate"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('ldap_type')
+ def ldap_type_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['active-directory', 'e-directory', 'sun', 'other']):
+ raise ValueError("must be one of enum values ('active-directory', 'e-directory', 'sun', 'other')")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LdapServerProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in server (list)
+ _items = []
+ if self.server:
+ for _item_server in self.server:
+ if _item_server:
+ _items.append(_item_server.to_dict())
+ _dict['server'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LdapServerProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "base": obj.get("base"),
+ "bind_dn": obj.get("bind_dn"),
+ "bind_password": obj.get("bind_password"),
+ "bind_timelimit": obj.get("bind_timelimit"),
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "ldap_type": obj.get("ldap_type"),
+ "name": obj.get("name"),
+ "retry_interval": obj.get("retry_interval"),
+ "server": [LdapServerProfilesServerInner.from_dict(_item) for _item in obj["server"]] if obj.get("server") is not None else None,
+ "snippet": obj.get("snippet"),
+ "ssl": obj.get("ssl"),
+ "timelimit": obj.get("timelimit"),
+ "verify_server_certificate": obj.get("verify_server_certificate")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/ldap_server_profiles_list_response.py b/scm/identity_services/models/ldap_server_profiles_list_response.py
new file mode 100644
index 00000000..17761cd3
--- /dev/null
+++ b/scm/identity_services/models/ldap_server_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.ldap_server_profiles import LdapServerProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LDAPServerProfilesListResponse(BaseModel):
+ """
+ LDAPServerProfilesListResponse
+ """ # noqa: E501
+ data: List[LdapServerProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LDAPServerProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LDAPServerProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = LdapServerProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [LdapServerProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/ldap_server_profiles_server_inner.py b/scm/identity_services/models/ldap_server_profiles_server_inner.py
new file mode 100644
index 00000000..9c724141
--- /dev/null
+++ b/scm/identity_services/models/ldap_server_profiles_server_inner.py
@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LdapServerProfilesServerInner(BaseModel):
+ """
+ LdapServerProfilesServerInner
+ """ # noqa: E501
+ address: Optional[StrictStr] = Field(default=None, description="The LDAP server IP address")
+ name: Optional[StrictStr] = Field(default=None, description="The LDAP server name")
+ port: Optional[Annotated[int, Field(le=65535, strict=True, ge=1)]] = Field(default=None, description="The LDAP server port")
+ __properties: ClassVar[List[str]] = ["address", "name", "port"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LdapServerProfilesServerInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LdapServerProfilesServerInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "address": obj.get("address"),
+ "name": obj.get("name"),
+ "port": obj.get("port")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/local_user_groups.py b/scm/identity_services/models/local_user_groups.py
new file mode 100644
index 00000000..075d6ff8
--- /dev/null
+++ b/scm/identity_services/models/local_user_groups.py
@@ -0,0 +1,138 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LocalUserGroups(BaseModel):
+ """
+ LocalUserGroups
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the local user group")
+ name: Annotated[str, Field(strict=True, max_length=31)] = Field(description="The name of the local user group")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ user: Optional[List[StrictStr]] = Field(default=None, description="The local user group users")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "name", "snippet", "user"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('name')
+ def name_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if not re.match(r"^[a-zA-Z0-9._-]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9._-]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LocalUserGroups from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LocalUserGroups from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "snippet": obj.get("snippet"),
+ "user": obj.get("user")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/local_user_groups_list_response.py b/scm/identity_services/models/local_user_groups_list_response.py
new file mode 100644
index 00000000..9933d6b0
--- /dev/null
+++ b/scm/identity_services/models/local_user_groups_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LocalUserGroupsListResponse(BaseModel):
+ """
+ LocalUserGroupsListResponse
+ """ # noqa: E501
+ data: List[LocalUserGroups]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LocalUserGroupsListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LocalUserGroupsListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = LocalUserGroups.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [LocalUserGroups.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/local_users.py b/scm/identity_services/models/local_users.py
new file mode 100644
index 00000000..5bb95764
--- /dev/null
+++ b/scm/identity_services/models/local_users.py
@@ -0,0 +1,133 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LocalUsers(BaseModel):
+ """
+ LocalUsers
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ disabled: Optional[StrictBool] = Field(default=False, description="Is the local user disabled?")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the local user")
+ name: Annotated[str, Field(strict=True, max_length=31)] = Field(description="The name of the local user")
+ password: Annotated[str, Field(strict=True, max_length=63)] = Field(description="The password of the local user")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "disabled", "folder", "id", "name", "password", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LocalUsers from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LocalUsers from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "disabled": obj.get("disabled") if obj.get("disabled") is not None else False,
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "password": obj.get("password"),
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/local_users_list_response.py b/scm/identity_services/models/local_users_list_response.py
new file mode 100644
index 00000000..5ce0278a
--- /dev/null
+++ b/scm/identity_services/models/local_users_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.local_users import LocalUsers
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LocalUsersListResponse(BaseModel):
+ """
+ LocalUsersListResponse
+ """ # noqa: E501
+ data: List[LocalUsers]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of LocalUsersListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of LocalUsersListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = LocalUsers.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [LocalUsers.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/mfa_servers.py b/scm/identity_services/models/mfa_servers.py
new file mode 100644
index 00000000..aa2c3284
--- /dev/null
+++ b/scm/identity_services/models/mfa_servers.py
@@ -0,0 +1,137 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.mfa_servers_mfa_vendor_type import MfaServersMfaVendorType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MfaServers(BaseModel):
+ """
+ MfaServers
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the MFA server")
+ mfa_cert_profile: StrictStr = Field(description="The MFA server certificate profile")
+ mfa_vendor_type: Optional[MfaServersMfaVendorType] = None
+ name: StrictStr = Field(description="The name of the MFA server profile")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "mfa_cert_profile", "mfa_vendor_type", "name", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MfaServers from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of mfa_vendor_type
+ if self.mfa_vendor_type:
+ _dict['mfa_vendor_type'] = self.mfa_vendor_type.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MfaServers from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "mfa_cert_profile": obj.get("mfa_cert_profile"),
+ "mfa_vendor_type": MfaServersMfaVendorType.from_dict(obj["mfa_vendor_type"]) if obj.get("mfa_vendor_type") is not None else None,
+ "name": obj.get("name"),
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/mfa_servers_list_response.py b/scm/identity_services/models/mfa_servers_list_response.py
new file mode 100644
index 00000000..b1d2f681
--- /dev/null
+++ b/scm/identity_services/models/mfa_servers_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.mfa_servers import MfaServers
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MFAServersListResponse(BaseModel):
+ """
+ MFAServersListResponse
+ """ # noqa: E501
+ data: List[MfaServers]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MFAServersListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MFAServersListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = MfaServers.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [MfaServers.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/mfa_servers_mfa_vendor_type.py b/scm/identity_services/models/mfa_servers_mfa_vendor_type.py
new file mode 100644
index 00000000..642a9dc6
--- /dev/null
+++ b/scm/identity_services/models/mfa_servers_mfa_vendor_type.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_duo_security_v2 import MfaServersMfaVendorTypeDuoSecurityV2
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_okta_adaptive_v1 import MfaServersMfaVendorTypeOktaAdaptiveV1
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_ping_identity_v1 import MfaServersMfaVendorTypePingIdentityV1
+from scm.identity_services.models.mfa_servers_mfa_vendor_type_rsa_securid_access_v1 import MfaServersMfaVendorTypeRsaSecuridAccessV1
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MfaServersMfaVendorType(BaseModel):
+ """
+ The MFA vendor type
+ """ # noqa: E501
+ duo_security_v2: Optional[MfaServersMfaVendorTypeDuoSecurityV2] = None
+ okta_adaptive_v1: Optional[MfaServersMfaVendorTypeOktaAdaptiveV1] = None
+ ping_identity_v1: Optional[MfaServersMfaVendorTypePingIdentityV1] = None
+ rsa_securid_access_v1: Optional[MfaServersMfaVendorTypeRsaSecuridAccessV1] = None
+ __properties: ClassVar[List[str]] = ["duo_security_v2", "okta_adaptive_v1", "ping_identity_v1", "rsa_securid_access_v1"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorType from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of duo_security_v2
+ if self.duo_security_v2:
+ _dict['duo_security_v2'] = self.duo_security_v2.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of okta_adaptive_v1
+ if self.okta_adaptive_v1:
+ _dict['okta_adaptive_v1'] = self.okta_adaptive_v1.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of ping_identity_v1
+ if self.ping_identity_v1:
+ _dict['ping_identity_v1'] = self.ping_identity_v1.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of rsa_securid_access_v1
+ if self.rsa_securid_access_v1:
+ _dict['rsa_securid_access_v1'] = self.rsa_securid_access_v1.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorType from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "duo_security_v2": MfaServersMfaVendorTypeDuoSecurityV2.from_dict(obj["duo_security_v2"]) if obj.get("duo_security_v2") is not None else None,
+ "okta_adaptive_v1": MfaServersMfaVendorTypeOktaAdaptiveV1.from_dict(obj["okta_adaptive_v1"]) if obj.get("okta_adaptive_v1") is not None else None,
+ "ping_identity_v1": MfaServersMfaVendorTypePingIdentityV1.from_dict(obj["ping_identity_v1"]) if obj.get("ping_identity_v1") is not None else None,
+ "rsa_securid_access_v1": MfaServersMfaVendorTypeRsaSecuridAccessV1.from_dict(obj["rsa_securid_access_v1"]) if obj.get("rsa_securid_access_v1") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/mfa_servers_mfa_vendor_type_duo_security_v2.py b/scm/identity_services/models/mfa_servers_mfa_vendor_type_duo_security_v2.py
new file mode 100644
index 00000000..2e476c54
--- /dev/null
+++ b/scm/identity_services/models/mfa_servers_mfa_vendor_type_duo_security_v2.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MfaServersMfaVendorTypeDuoSecurityV2(BaseModel):
+ """
+ Integration with [Duo Security](https://duo.com/product)
+ """ # noqa: E501
+ duo_api_host: Annotated[str, Field(min_length=16, strict=True)] = Field(description="Duo Security API hostname")
+ duo_baseuri: Annotated[str, Field(min_length=2, strict=True)] = Field(description="Duo Security API base URI")
+ duo_integration_key: Annotated[str, Field(min_length=16, strict=True)] = Field(description="Duo Security integration key")
+ duo_secret_key: Annotated[str, Field(min_length=16, strict=True)] = Field(description="Duo Security secret key")
+ duo_timeout: Annotated[int, Field(le=600, strict=True, ge=5)] = Field(description="Duo Security timeout (seconds)")
+ __properties: ClassVar[List[str]] = ["duo_api_host", "duo_baseuri", "duo_integration_key", "duo_secret_key", "duo_timeout"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypeDuoSecurityV2 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypeDuoSecurityV2 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "duo_api_host": obj.get("duo_api_host"),
+ "duo_baseuri": obj.get("duo_baseuri") if obj.get("duo_baseuri") is not None else '/auth/v2',
+ "duo_integration_key": obj.get("duo_integration_key"),
+ "duo_secret_key": obj.get("duo_secret_key"),
+ "duo_timeout": obj.get("duo_timeout") if obj.get("duo_timeout") is not None else 30
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/mfa_servers_mfa_vendor_type_okta_adaptive_v1.py b/scm/identity_services/models/mfa_servers_mfa_vendor_type_okta_adaptive_v1.py
new file mode 100644
index 00000000..5e9bfdf3
--- /dev/null
+++ b/scm/identity_services/models/mfa_servers_mfa_vendor_type_okta_adaptive_v1.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MfaServersMfaVendorTypeOktaAdaptiveV1(BaseModel):
+ """
+ Integration with [Okta Adaptive MFA](https://www.okta.com/products/adaptive-multi-factor-authentication)
+ """ # noqa: E501
+ okta_api_host: Annotated[str, Field(min_length=10, strict=True)] = Field(description="Okta API hostname")
+ okta_baseuri: Annotated[str, Field(min_length=2, strict=True)]
+ okta_org: StrictStr = Field(description="Okta organization")
+ okta_timeout: Annotated[int, Field(le=600, strict=True, ge=5)] = Field(description="Okta timeout (seconds)")
+ okta_token: Annotated[str, Field(min_length=8, strict=True)] = Field(description="Okta API token")
+ __properties: ClassVar[List[str]] = ["okta_api_host", "okta_baseuri", "okta_org", "okta_timeout", "okta_token"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypeOktaAdaptiveV1 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypeOktaAdaptiveV1 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "okta_api_host": obj.get("okta_api_host"),
+ "okta_baseuri": obj.get("okta_baseuri") if obj.get("okta_baseuri") is not None else '/api/v1',
+ "okta_org": obj.get("okta_org"),
+ "okta_timeout": obj.get("okta_timeout") if obj.get("okta_timeout") is not None else 30,
+ "okta_token": obj.get("okta_token")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/mfa_servers_mfa_vendor_type_ping_identity_v1.py b/scm/identity_services/models/mfa_servers_mfa_vendor_type_ping_identity_v1.py
new file mode 100644
index 00000000..11ee912f
--- /dev/null
+++ b/scm/identity_services/models/mfa_servers_mfa_vendor_type_ping_identity_v1.py
@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MfaServersMfaVendorTypePingIdentityV1(BaseModel):
+ """
+ Integation with [Ping Identity](https://www.pingidentity.com/en/platform.html)
+ """ # noqa: E501
+ ping_api_host: Annotated[str, Field(min_length=16, strict=True)] = Field(description="Ping Identity API hostname")
+ ping_baseuri: Annotated[str, Field(min_length=2, strict=True)] = Field(description="Ping Identity API base URI")
+ ping_org_alias: Optional[Annotated[str, Field(min_length=8, strict=True)]] = Field(default=None, description="Ping Identity client organization ID")
+ ping_timeout: Annotated[int, Field(le=600, strict=True, ge=5)] = Field(description="Ping Identity timeout (seconds)")
+ ping_token: Annotated[str, Field(min_length=8, strict=True)] = Field(description="Ping Identity API token")
+ ping_use_base64_key: Annotated[str, Field(min_length=8, strict=True)] = Field(description="Ping Identity Base64 key")
+ __properties: ClassVar[List[str]] = ["ping_api_host", "ping_baseuri", "ping_org_alias", "ping_timeout", "ping_token", "ping_use_base64_key"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypePingIdentityV1 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypePingIdentityV1 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ping_api_host": obj.get("ping_api_host") if obj.get("ping_api_host") is not None else 'idpxny3lm.pingidentity.com',
+ "ping_baseuri": obj.get("ping_baseuri") if obj.get("ping_baseuri") is not None else '/pingid/rest/4',
+ "ping_org_alias": obj.get("ping_org_alias"),
+ "ping_timeout": obj.get("ping_timeout") if obj.get("ping_timeout") is not None else 30,
+ "ping_token": obj.get("ping_token"),
+ "ping_use_base64_key": obj.get("ping_use_base64_key")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/mfa_servers_mfa_vendor_type_rsa_securid_access_v1.py b/scm/identity_services/models/mfa_servers_mfa_vendor_type_rsa_securid_access_v1.py
new file mode 100644
index 00000000..24b2c402
--- /dev/null
+++ b/scm/identity_services/models/mfa_servers_mfa_vendor_type_rsa_securid_access_v1.py
@@ -0,0 +1,99 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class MfaServersMfaVendorTypeRsaSecuridAccessV1(BaseModel):
+ """
+ Integration with [RSA SecurID](https://www.rsa.com/products/securid/)
+ """ # noqa: E501
+ rsa_accessid: Optional[Annotated[str, Field(min_length=8, strict=True)]] = Field(default=None, description="RSA SecurID access ID")
+ rsa_accesskey: Optional[Annotated[str, Field(min_length=8, strict=True)]] = Field(default=None, description="RSA SecurID access key")
+ rsa_api_host: Optional[Annotated[str, Field(min_length=10, strict=True)]] = Field(default=None, description="RSA SecurID hostname")
+ rsa_assurancepolicyid: Optional[Annotated[str, Field(min_length=3, strict=True)]] = Field(default=None, description="RSA SecurID assurance level")
+ rsa_baseuri: Optional[Annotated[str, Field(min_length=2, strict=True)]] = Field(default='/mfa/v1_1', description="RSA SecurID API base URI")
+ rsa_timeout: Optional[Annotated[int, Field(le=600, strict=True, ge=5)]] = Field(default=30, description="RSA SecurID timeout (seconds)")
+ __properties: ClassVar[List[str]] = ["rsa_accessid", "rsa_accesskey", "rsa_api_host", "rsa_assurancepolicyid", "rsa_baseuri", "rsa_timeout"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypeRsaSecuridAccessV1 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of MfaServersMfaVendorTypeRsaSecuridAccessV1 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "rsa_accessid": obj.get("rsa_accessid"),
+ "rsa_accesskey": obj.get("rsa_accesskey"),
+ "rsa_api_host": obj.get("rsa_api_host"),
+ "rsa_assurancepolicyid": obj.get("rsa_assurancepolicyid"),
+ "rsa_baseuri": obj.get("rsa_baseuri") if obj.get("rsa_baseuri") is not None else '/mfa/v1_1',
+ "rsa_timeout": obj.get("rsa_timeout") if obj.get("rsa_timeout") is not None else 30
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/ocsp_responders.py b/scm/identity_services/models/ocsp_responders.py
new file mode 100644
index 00000000..3b467f0c
--- /dev/null
+++ b/scm/identity_services/models/ocsp_responders.py
@@ -0,0 +1,138 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OcspResponders(BaseModel):
+ """
+ OcspResponders
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ host_name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The hostname or IP address of the OCSP server")
+ id: StrictStr = Field(description="The UUID of the OCSP responder profile")
+ name: Annotated[str, Field(strict=True, max_length=63)] = Field(description="The name of the OCSP responder profile")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["device", "folder", "host_name", "id", "name", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('name')
+ def name_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if not re.match(r"^[a-zA-Z0-9._-]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9._-]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of OcspResponders from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of OcspResponders from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "host_name": obj.get("host_name"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/ocsp_responders_list_response.py b/scm/identity_services/models/ocsp_responders_list_response.py
new file mode 100644
index 00000000..a0a05cfb
--- /dev/null
+++ b/scm/identity_services/models/ocsp_responders_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.ocsp_responders import OcspResponders
+from typing import Optional, Set
+from typing_extensions import Self
+
+class OCSPRespondersListResponse(BaseModel):
+ """
+ OCSPRespondersListResponse
+ """ # noqa: E501
+ data: List[OcspResponders]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of OCSPRespondersListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of OCSPRespondersListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = OcspResponders.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [OcspResponders.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/radius_server_profiles.py b/scm/identity_services/models/radius_server_profiles.py
new file mode 100644
index 00000000..72ad7599
--- /dev/null
+++ b/scm/identity_services/models/radius_server_profiles.py
@@ -0,0 +1,149 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.radius_server_profiles_protocol import RadiusServerProfilesProtocol
+from scm.identity_services.models.radius_server_profiles_server_inner import RadiusServerProfilesServerInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RadiusServerProfiles(BaseModel):
+ """
+ RadiusServerProfiles
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the RADIUS server profile")
+ name: StrictStr = Field(description="The name of the RADIUS server profile")
+ protocol: RadiusServerProfilesProtocol
+ retries: Optional[Annotated[int, Field(le=5, strict=True, ge=1)]] = Field(default=None, description="The number of RADIUS server retries")
+ server: List[RadiusServerProfilesServerInner]
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ timeout: Optional[Annotated[int, Field(le=120, strict=True, ge=1)]] = Field(default=None, description="The RADIUS server authentication timeout (seconds)")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "name", "protocol", "retries", "server", "snippet", "timeout"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RadiusServerProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of protocol
+ if self.protocol:
+ _dict['protocol'] = self.protocol.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of each item in server (list)
+ _items = []
+ if self.server:
+ for _item_server in self.server:
+ if _item_server:
+ _items.append(_item_server.to_dict())
+ _dict['server'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RadiusServerProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "protocol": RadiusServerProfilesProtocol.from_dict(obj["protocol"]) if obj.get("protocol") is not None else None,
+ "retries": obj.get("retries"),
+ "server": [RadiusServerProfilesServerInner.from_dict(_item) for _item in obj["server"]] if obj.get("server") is not None else None,
+ "snippet": obj.get("snippet"),
+ "timeout": obj.get("timeout")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/radius_server_profiles_list_response.py b/scm/identity_services/models/radius_server_profiles_list_response.py
new file mode 100644
index 00000000..705368ac
--- /dev/null
+++ b/scm/identity_services/models/radius_server_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RADIUSServerProfilesListResponse(BaseModel):
+ """
+ RADIUSServerProfilesListResponse
+ """ # noqa: E501
+ data: List[RadiusServerProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RADIUSServerProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RADIUSServerProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = RadiusServerProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [RadiusServerProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/radius_server_profiles_protocol.py b/scm/identity_services/models/radius_server_profiles_protocol.py
new file mode 100644
index 00000000..55b3a726
--- /dev/null
+++ b/scm/identity_services/models/radius_server_profiles_protocol.py
@@ -0,0 +1,107 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from scm.identity_services.models.radius_server_profiles_protocol_eapttls_with_pap import RadiusServerProfilesProtocolEAPTTLSWithPAP
+from scm.identity_services.models.radius_server_profiles_protocol_peapmschapv2 import RadiusServerProfilesProtocolPEAPMSCHAPv2
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RadiusServerProfilesProtocol(BaseModel):
+ """
+ The RADIUS authentication protocol
+ """ # noqa: E501
+ chap: Optional[Dict[str, Any]] = Field(default=None, alias="CHAP")
+ eap_ttls_with_pap: Optional[RadiusServerProfilesProtocolEAPTTLSWithPAP] = Field(default=None, alias="EAP_TTLS_with_PAP")
+ pap: Optional[Dict[str, Any]] = Field(default=None, alias="PAP")
+ peap_mschapv2: Optional[RadiusServerProfilesProtocolPEAPMSCHAPv2] = Field(default=None, alias="PEAP_MSCHAPv2")
+ peap_with_gtc: Optional[RadiusServerProfilesProtocolEAPTTLSWithPAP] = Field(default=None, alias="PEAP_with_GTC")
+ __properties: ClassVar[List[str]] = ["CHAP", "EAP_TTLS_with_PAP", "PAP", "PEAP_MSCHAPv2", "PEAP_with_GTC"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesProtocol from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of eap_ttls_with_pap
+ if self.eap_ttls_with_pap:
+ _dict['EAP_TTLS_with_PAP'] = self.eap_ttls_with_pap.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of peap_mschapv2
+ if self.peap_mschapv2:
+ _dict['PEAP_MSCHAPv2'] = self.peap_mschapv2.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of peap_with_gtc
+ if self.peap_with_gtc:
+ _dict['PEAP_with_GTC'] = self.peap_with_gtc.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesProtocol from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "CHAP": obj.get("CHAP"),
+ "EAP_TTLS_with_PAP": RadiusServerProfilesProtocolEAPTTLSWithPAP.from_dict(obj["EAP_TTLS_with_PAP"]) if obj.get("EAP_TTLS_with_PAP") is not None else None,
+ "PAP": obj.get("PAP"),
+ "PEAP_MSCHAPv2": RadiusServerProfilesProtocolPEAPMSCHAPv2.from_dict(obj["PEAP_MSCHAPv2"]) if obj.get("PEAP_MSCHAPv2") is not None else None,
+ "PEAP_with_GTC": RadiusServerProfilesProtocolEAPTTLSWithPAP.from_dict(obj["PEAP_with_GTC"]) if obj.get("PEAP_with_GTC") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/radius_server_profiles_protocol_eapttls_with_pap.py b/scm/identity_services/models/radius_server_profiles_protocol_eapttls_with_pap.py
new file mode 100644
index 00000000..3af3f8ef
--- /dev/null
+++ b/scm/identity_services/models/radius_server_profiles_protocol_eapttls_with_pap.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RadiusServerProfilesProtocolEAPTTLSWithPAP(BaseModel):
+ """
+ RadiusServerProfilesProtocolEAPTTLSWithPAP
+ """ # noqa: E501
+ anon_outer_id: Optional[StrictBool] = None
+ radius_cert_profile: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["anon_outer_id", "radius_cert_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesProtocolEAPTTLSWithPAP from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesProtocolEAPTTLSWithPAP from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "anon_outer_id": obj.get("anon_outer_id"),
+ "radius_cert_profile": obj.get("radius_cert_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/radius_server_profiles_protocol_peapmschapv2.py b/scm/identity_services/models/radius_server_profiles_protocol_peapmschapv2.py
new file mode 100644
index 00000000..3c05c093
--- /dev/null
+++ b/scm/identity_services/models/radius_server_profiles_protocol_peapmschapv2.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RadiusServerProfilesProtocolPEAPMSCHAPv2(BaseModel):
+ """
+ RadiusServerProfilesProtocolPEAPMSCHAPv2
+ """ # noqa: E501
+ allow_pwd_change: Optional[StrictBool] = None
+ anon_outer_id: Optional[StrictBool] = None
+ radius_cert_profile: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["allow_pwd_change", "anon_outer_id", "radius_cert_profile"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesProtocolPEAPMSCHAPv2 from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesProtocolPEAPMSCHAPv2 from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "allow_pwd_change": obj.get("allow_pwd_change"),
+ "anon_outer_id": obj.get("anon_outer_id"),
+ "radius_cert_profile": obj.get("radius_cert_profile")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/radius_server_profiles_server_inner.py b/scm/identity_services/models/radius_server_profiles_server_inner.py
new file mode 100644
index 00000000..54ea8b37
--- /dev/null
+++ b/scm/identity_services/models/radius_server_profiles_server_inner.py
@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RadiusServerProfilesServerInner(BaseModel):
+ """
+ The RADIUS server configuration
+ """ # noqa: E501
+ ip_address: Optional[StrictStr] = Field(default=None, description="The IP address of the RADIUS server")
+ name: Optional[StrictStr] = Field(default=None, description="The name of the RADIUS server")
+ port: Optional[Annotated[int, Field(le=65535, strict=True, ge=1)]] = Field(default=None, description="The RADIUS server port")
+ secret: Optional[Annotated[str, Field(strict=True, max_length=128)]] = Field(default=None, description="The RADIUS secret")
+ __properties: ClassVar[List[str]] = ["ip_address", "name", "port", "secret"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesServerInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RadiusServerProfilesServerInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "ip_address": obj.get("ip_address"),
+ "name": obj.get("name"),
+ "port": obj.get("port"),
+ "secret": obj.get("secret")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/rule_based_move.py b/scm/identity_services/models/rule_based_move.py
new file mode 100644
index 00000000..5010a967
--- /dev/null
+++ b/scm/identity_services/models/rule_based_move.py
@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RuleBasedMove(BaseModel):
+ """
+ RuleBasedMove
+ """ # noqa: E501
+ destination: StrictStr = Field(description="The position of the rule relative to other rules in this rulebase.")
+ destination_rule: Optional[StrictStr] = Field(default=None, description="A destination target rule UUID. This is only used if the `destination` value is `before` or `after`.")
+ rulebase: StrictStr = Field(description="The position of the rule relative to the local rulebase")
+ __properties: ClassVar[List[str]] = ["destination", "destination_rule", "rulebase"]
+
+ @field_validator('destination')
+ def destination_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['top', 'bottom', 'before', 'after']):
+ raise ValueError("must be one of enum values ('top', 'bottom', 'before', 'after')")
+ return value
+
+ @field_validator('rulebase')
+ def rulebase_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['pre', 'post']):
+ raise ValueError("must be one of enum values ('pre', 'post')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of RuleBasedMove from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of RuleBasedMove from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "destination": obj.get("destination"),
+ "destination_rule": obj.get("destination_rule"),
+ "rulebase": obj.get("rulebase")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/saml_server_profiles.py b/scm/identity_services/models/saml_server_profiles.py
new file mode 100644
index 00000000..adcae0fd
--- /dev/null
+++ b/scm/identity_services/models/saml_server_profiles.py
@@ -0,0 +1,164 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SamlServerProfiles(BaseModel):
+ """
+ SamlServerProfiles
+ """ # noqa: E501
+ certificate: Annotated[str, Field(strict=True, max_length=63)] = Field(description="The identity provider certificate")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ entity_id: Annotated[str, Field(min_length=1, strict=True, max_length=1024)] = Field(description="The identity provider ID")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the SAML server profile")
+ max_clock_skew: Optional[Annotated[int, Field(le=900, strict=True, ge=1)]] = Field(default=None, description="Maxiumum clock skew")
+ name: StrictStr = Field(description="The name of the SAML server profile")
+ slo_bindings: Optional[StrictStr] = Field(default=None, description="SAML HTTP binding for SLO requests to the identity provider")
+ slo_url: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="Identity provider SLO URL")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ sso_bindings: StrictStr = Field(description="SAML HTTP binding for SSO requests to the identity provider")
+ sso_url: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="Identity provider SSO URL")
+ validate_idp_certificate: Optional[StrictBool] = Field(default=None, description="Validate the identity provider certificate?")
+ want_auth_requests_signed: Optional[StrictBool] = Field(default=None, description="Sign SAML message to the identity provider?")
+ __properties: ClassVar[List[str]] = ["certificate", "device", "entity_id", "folder", "id", "max_clock_skew", "name", "slo_bindings", "slo_url", "snippet", "sso_bindings", "sso_url", "validate_idp_certificate", "want_auth_requests_signed"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('slo_bindings')
+ def slo_bindings_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['post', 'redirect']):
+ raise ValueError("must be one of enum values ('post', 'redirect')")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('sso_bindings')
+ def sso_bindings_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['post', 'redirect']):
+ raise ValueError("must be one of enum values ('post', 'redirect')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SamlServerProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SamlServerProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "certificate": obj.get("certificate"),
+ "device": obj.get("device"),
+ "entity_id": obj.get("entity_id"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "max_clock_skew": obj.get("max_clock_skew"),
+ "name": obj.get("name"),
+ "slo_bindings": obj.get("slo_bindings"),
+ "slo_url": obj.get("slo_url"),
+ "snippet": obj.get("snippet"),
+ "sso_bindings": obj.get("sso_bindings") if obj.get("sso_bindings") is not None else 'post',
+ "sso_url": obj.get("sso_url"),
+ "validate_idp_certificate": obj.get("validate_idp_certificate"),
+ "want_auth_requests_signed": obj.get("want_auth_requests_signed")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/saml_server_profiles_list_response.py b/scm/identity_services/models/saml_server_profiles_list_response.py
new file mode 100644
index 00000000..26b49866
--- /dev/null
+++ b/scm/identity_services/models/saml_server_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SAMLServerProfilesListResponse(BaseModel):
+ """
+ SAMLServerProfilesListResponse
+ """ # noqa: E501
+ data: List[SamlServerProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SAMLServerProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SAMLServerProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = SamlServerProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [SamlServerProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/scep_profiles.py b/scm/identity_services/models/scep_profiles.py
new file mode 100644
index 00000000..d3ed60f3
--- /dev/null
+++ b/scm/identity_services/models/scep_profiles.py
@@ -0,0 +1,192 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.scep_profiles_algorithm import ScepProfilesAlgorithm
+from scm.identity_services.models.scep_profiles_certificate_attributes import ScepProfilesCertificateAttributes
+from scm.identity_services.models.scep_profiles_scep_challenge import ScepProfilesScepChallenge
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScepProfiles(BaseModel):
+ """
+ ScepProfiles
+ """ # noqa: E501
+ algorithm: ScepProfilesAlgorithm
+ ca_identity_name: StrictStr = Field(description="Certificate Authority Identity")
+ certificate_attributes: Optional[ScepProfilesCertificateAttributes] = None
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ digest: StrictStr = Field(description="Digest for CSR")
+ fingerprint: Optional[StrictStr] = Field(default=None, description="CA Certificate Fingerprint")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the SCEP profile")
+ name: Annotated[str, Field(strict=True, max_length=31)] = Field(description="The name of the SCEP profile")
+ scep_ca_cert: Optional[StrictStr] = Field(default=None, description="SCEP Server CA Certificate")
+ scep_challenge: ScepProfilesScepChallenge
+ scep_client_cert: Optional[StrictStr] = Field(default=None, description="SCEP Client Certificate")
+ scep_url: StrictStr = Field(description="SCEP server URL")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ subject: StrictStr = Field(description="Subject")
+ use_as_digital_signature: Optional[StrictBool] = Field(default=None, description="Use as digital signature?")
+ use_for_key_encipherment: Optional[StrictBool] = Field(default=None, description="Use for key encipherment?")
+ __properties: ClassVar[List[str]] = ["algorithm", "ca_identity_name", "certificate_attributes", "device", "digest", "fingerprint", "folder", "id", "name", "scep_ca_cert", "scep_challenge", "scep_client_cert", "scep_url", "snippet", "subject", "use_as_digital_signature", "use_for_key_encipherment"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('digest')
+ def digest_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['sha1', 'sha256', 'sha384', 'sha512']):
+ raise ValueError("must be one of enum values ('sha1', 'sha256', 'sha384', 'sha512')")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('scep_ca_cert')
+ def scep_ca_cert_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['Authentication Cookie CA', 'Forward-Trust-CA', 'Forward-Trust-CA-ECDSA', 'Forward-UnTrust-CA', 'Forward-UnTrust-CA-ECDSA', 'Global Authentication Cookie CA', 'GlobalSign-Root-CA', 'Root CA']):
+ raise ValueError("must be one of enum values ('Authentication Cookie CA', 'Forward-Trust-CA', 'Forward-Trust-CA-ECDSA', 'Forward-UnTrust-CA', 'Forward-UnTrust-CA-ECDSA', 'Global Authentication Cookie CA', 'GlobalSign-Root-CA', 'Root CA')")
+ return value
+
+ @field_validator('scep_client_cert')
+ def scep_client_cert_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['Authentication Cookie CA', 'Forward-Trust-CA', 'Forward-Trust-CA-ECDSA', 'Forward-UnTrust-CA', 'Forward-UnTrust-CA-ECDSA', 'Global Authentication Cookie CA', 'GlobalSign-Root-CA', 'Root CA']):
+ raise ValueError("must be one of enum values ('Authentication Cookie CA', 'Forward-Trust-CA', 'Forward-Trust-CA-ECDSA', 'Forward-UnTrust-CA', 'Forward-UnTrust-CA-ECDSA', 'Global Authentication Cookie CA', 'GlobalSign-Root-CA', 'Root CA')")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ScepProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of algorithm
+ if self.algorithm:
+ _dict['algorithm'] = self.algorithm.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of certificate_attributes
+ if self.certificate_attributes:
+ _dict['certificate_attributes'] = self.certificate_attributes.to_dict()
+ # override the default output from pydantic by calling `to_dict()` of scep_challenge
+ if self.scep_challenge:
+ _dict['scep_challenge'] = self.scep_challenge.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ScepProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "algorithm": ScepProfilesAlgorithm.from_dict(obj["algorithm"]) if obj.get("algorithm") is not None else None,
+ "ca_identity_name": obj.get("ca_identity_name"),
+ "certificate_attributes": ScepProfilesCertificateAttributes.from_dict(obj["certificate_attributes"]) if obj.get("certificate_attributes") is not None else None,
+ "device": obj.get("device"),
+ "digest": obj.get("digest"),
+ "fingerprint": obj.get("fingerprint"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "scep_ca_cert": obj.get("scep_ca_cert"),
+ "scep_challenge": ScepProfilesScepChallenge.from_dict(obj["scep_challenge"]) if obj.get("scep_challenge") is not None else None,
+ "scep_client_cert": obj.get("scep_client_cert"),
+ "scep_url": obj.get("scep_url"),
+ "snippet": obj.get("snippet"),
+ "subject": obj.get("subject") if obj.get("subject") is not None else 'CN=$USERNAME',
+ "use_as_digital_signature": obj.get("use_as_digital_signature"),
+ "use_for_key_encipherment": obj.get("use_for_key_encipherment")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/scep_profiles_algorithm.py b/scm/identity_services/models/scep_profiles_algorithm.py
new file mode 100644
index 00000000..e1f0cf97
--- /dev/null
+++ b/scm/identity_services/models/scep_profiles_algorithm.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.scep_profiles_algorithm_rsa import ScepProfilesAlgorithmRsa
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScepProfilesAlgorithm(BaseModel):
+ """
+ ScepProfilesAlgorithm
+ """ # noqa: E501
+ rsa: ScepProfilesAlgorithmRsa
+ __properties: ClassVar[List[str]] = ["rsa"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ScepProfilesAlgorithm from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of rsa
+ if self.rsa:
+ _dict['rsa'] = self.rsa.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ScepProfilesAlgorithm from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "rsa": ScepProfilesAlgorithmRsa.from_dict(obj["rsa"]) if obj.get("rsa") is not None else None
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/scep_profiles_algorithm_rsa.py b/scm/identity_services/models/scep_profiles_algorithm_rsa.py
new file mode 100644
index 00000000..c9a1238d
--- /dev/null
+++ b/scm/identity_services/models/scep_profiles_algorithm_rsa.py
@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScepProfilesAlgorithmRsa(BaseModel):
+ """
+ Key length (bits)
+ """ # noqa: E501
+ rsa_nbits: StrictStr
+ __properties: ClassVar[List[str]] = ["rsa_nbits"]
+
+ @field_validator('rsa_nbits')
+ def rsa_nbits_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['1024', '2048', '3072']):
+ raise ValueError("must be one of enum values ('1024', '2048', '3072')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ScepProfilesAlgorithmRsa from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ScepProfilesAlgorithmRsa from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "rsa_nbits": obj.get("rsa_nbits")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/scep_profiles_certificate_attributes.py b/scm/identity_services/models/scep_profiles_certificate_attributes.py
new file mode 100644
index 00000000..654e2c6c
--- /dev/null
+++ b/scm/identity_services/models/scep_profiles_certificate_attributes.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScepProfilesCertificateAttributes(BaseModel):
+ """
+ Subject Alternative name type
+ """ # noqa: E501
+ dnsname: Optional[StrictStr] = None
+ rfc822name: Optional[StrictStr] = None
+ uniform_resource_identifier: Optional[StrictStr] = None
+ __properties: ClassVar[List[str]] = ["dnsname", "rfc822name", "uniform_resource_identifier"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ScepProfilesCertificateAttributes from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ScepProfilesCertificateAttributes from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "dnsname": obj.get("dnsname"),
+ "rfc822name": obj.get("rfc822name"),
+ "uniform_resource_identifier": obj.get("uniform_resource_identifier")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/scep_profiles_list_response.py b/scm/identity_services/models/scep_profiles_list_response.py
new file mode 100644
index 00000000..f555fb4d
--- /dev/null
+++ b/scm/identity_services/models/scep_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.scep_profiles import ScepProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SCEPProfilesListResponse(BaseModel):
+ """
+ SCEPProfilesListResponse
+ """ # noqa: E501
+ data: List[ScepProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of SCEPProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of SCEPProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = ScepProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [ScepProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/scep_profiles_scep_challenge.py b/scm/identity_services/models/scep_profiles_scep_challenge.py
new file mode 100644
index 00000000..dc777002
--- /dev/null
+++ b/scm/identity_services/models/scep_profiles_scep_challenge.py
@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.scep_profiles_scep_challenge_dynamic import ScepProfilesScepChallengeDynamic
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScepProfilesScepChallenge(BaseModel):
+ """
+ One Time Password Challenge
+ """ # noqa: E501
+ dynamic: Optional[ScepProfilesScepChallengeDynamic] = None
+ fixed: Optional[Annotated[str, Field(strict=True, max_length=1024)]] = Field(default=None, description="Challenge to use for SCEP server on mobile clients")
+ var_none: Optional[Dict[str, Any]] = Field(default=None, description="No OTP", alias="none")
+ __properties: ClassVar[List[str]] = ["dynamic", "fixed", "none"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ScepProfilesScepChallenge from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of dynamic
+ if self.dynamic:
+ _dict['dynamic'] = self.dynamic.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ScepProfilesScepChallenge from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "dynamic": ScepProfilesScepChallengeDynamic.from_dict(obj["dynamic"]) if obj.get("dynamic") is not None else None,
+ "fixed": obj.get("fixed"),
+ "none": obj.get("none")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/scep_profiles_scep_challenge_dynamic.py b/scm/identity_services/models/scep_profiles_scep_challenge_dynamic.py
new file mode 100644
index 00000000..2d119f8a
--- /dev/null
+++ b/scm/identity_services/models/scep_profiles_scep_challenge_dynamic.py
@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ScepProfilesScepChallengeDynamic(BaseModel):
+ """
+ ScepProfilesScepChallengeDynamic
+ """ # noqa: E501
+ otp_server_url: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="OTP server URL")
+ password: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="OTP password")
+ username: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="OTP username")
+ __properties: ClassVar[List[str]] = ["otp_server_url", "password", "username"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of ScepProfilesScepChallengeDynamic from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of ScepProfilesScepChallengeDynamic from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "otp_server_url": obj.get("otp_server_url"),
+ "password": obj.get("password"),
+ "username": obj.get("username")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/tacacs_server_profiles.py b/scm/identity_services/models/tacacs_server_profiles.py
new file mode 100644
index 00000000..81f75359
--- /dev/null
+++ b/scm/identity_services/models/tacacs_server_profiles.py
@@ -0,0 +1,152 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.tacacs_server_profiles_server_inner import TacacsServerProfilesServerInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TacacsServerProfiles(BaseModel):
+ """
+ TacacsServerProfiles
+ """ # noqa: E501
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the TACACS+ server profile")
+ name: StrictStr = Field(description="The name of the TACACS+ server profile")
+ protocol: StrictStr = Field(description="The TACACS+ authentication protocol")
+ server: List[TacacsServerProfilesServerInner] = Field(description="The TACACS+ server configuration")
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ timeout: Optional[Annotated[int, Field(le=30, strict=True, ge=1)]] = Field(default=None, description="The TACACS+ timeout (seconds)")
+ use_single_connection: Optional[StrictBool] = Field(default=None, description="Use a single TACACS+ connection?")
+ __properties: ClassVar[List[str]] = ["device", "folder", "id", "name", "protocol", "server", "snippet", "timeout", "use_single_connection"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('protocol')
+ def protocol_validate_enum(cls, value):
+ """Validates the enum"""
+ if value not in set(['CHAP', 'PAP']):
+ raise ValueError("must be one of enum values ('CHAP', 'PAP')")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TacacsServerProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in server (list)
+ _items = []
+ if self.server:
+ for _item_server in self.server:
+ if _item_server:
+ _items.append(_item_server.to_dict())
+ _dict['server'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TacacsServerProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "protocol": obj.get("protocol"),
+ "server": [TacacsServerProfilesServerInner.from_dict(_item) for _item in obj["server"]] if obj.get("server") is not None else None,
+ "snippet": obj.get("snippet"),
+ "timeout": obj.get("timeout"),
+ "use_single_connection": obj.get("use_single_connection")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/tacacs_server_profiles_list_response.py b/scm/identity_services/models/tacacs_server_profiles_list_response.py
new file mode 100644
index 00000000..9a801e2b
--- /dev/null
+++ b/scm/identity_services/models/tacacs_server_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TACACSServerProfilesListResponse(BaseModel):
+ """
+ TACACSServerProfilesListResponse
+ """ # noqa: E501
+ data: List[TacacsServerProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TACACSServerProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TACACSServerProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = TacacsServerProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [TacacsServerProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/tacacs_server_profiles_server_inner.py b/scm/identity_services/models/tacacs_server_profiles_server_inner.py
new file mode 100644
index 00000000..080039e1
--- /dev/null
+++ b/scm/identity_services/models/tacacs_server_profiles_server_inner.py
@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TacacsServerProfilesServerInner(BaseModel):
+ """
+ TacacsServerProfilesServerInner
+ """ # noqa: E501
+ address: Optional[StrictStr] = Field(default=None, description="The IP address of the TACACS+ server")
+ name: Optional[StrictStr] = Field(default=None, description="The name of the TACACS+ server")
+ port: Optional[Annotated[int, Field(le=65535, strict=True, ge=1)]] = Field(default=None, description="The TACACS+ server port")
+ secret: Optional[SecretStr] = Field(default=None, description="The TACACS+ secret")
+ __properties: ClassVar[List[str]] = ["address", "name", "port", "secret"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TacacsServerProfilesServerInner from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TacacsServerProfilesServerInner from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "address": obj.get("address"),
+ "name": obj.get("name"),
+ "port": obj.get("port"),
+ "secret": obj.get("secret")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/tls_service_profiles.py b/scm/identity_services/models/tls_service_profiles.py
new file mode 100644
index 00000000..c470a0c5
--- /dev/null
+++ b/scm/identity_services/models/tls_service_profiles.py
@@ -0,0 +1,144 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from scm.identity_services.models.tls_service_profiles_protocol_settings import TlsServiceProfilesProtocolSettings
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TlsServiceProfiles(BaseModel):
+ """
+ TlsServiceProfiles
+ """ # noqa: E501
+ certificate: Annotated[str, Field(strict=True, max_length=255)] = Field(description="Certificate name")
+ device: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The device in which the resource is defined")
+ folder: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The folder in which the resource is defined")
+ id: StrictStr = Field(description="The UUID of the TLS service profile")
+ name: Annotated[str, Field(strict=True, max_length=127)] = Field(description="TLS service profile name. The value is `muCustomDomainSSLProfile` when it is used on mobile-agent infra settings.")
+ protocol_settings: TlsServiceProfilesProtocolSettings
+ snippet: Optional[Annotated[str, Field(strict=True, max_length=64)]] = Field(default=None, description="The snippet in which the resource is defined")
+ __properties: ClassVar[List[str]] = ["certificate", "device", "folder", "id", "name", "protocol_settings", "snippet"]
+
+ @field_validator('device')
+ def device_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('folder')
+ def folder_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ @field_validator('name')
+ def name_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if not re.match(r"^[a-zA-Z0-9._-]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9._-]+$/")
+ return value
+
+ @field_validator('snippet')
+ def snippet_validate_regular_expression(cls, value):
+ """Validates the regular expression"""
+ if value is None:
+ return value
+
+ if not re.match(r"^[a-zA-Z\d\-_\. ]+$", value):
+ raise ValueError(r"must validate the regular expression /^[a-zA-Z\d\-_\. ]+$/")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TlsServiceProfiles from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of protocol_settings
+ if self.protocol_settings:
+ _dict['protocol_settings'] = self.protocol_settings.to_dict()
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TlsServiceProfiles from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "certificate": obj.get("certificate"),
+ "device": obj.get("device"),
+ "folder": obj.get("folder"),
+ "id": obj.get("id"),
+ "name": obj.get("name"),
+ "protocol_settings": TlsServiceProfilesProtocolSettings.from_dict(obj["protocol_settings"]) if obj.get("protocol_settings") is not None else None,
+ "snippet": obj.get("snippet")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/tls_service_profiles_list_response.py b/scm/identity_services/models/tls_service_profiles_list_response.py
new file mode 100644
index 00000000..637f4d37
--- /dev/null
+++ b/scm/identity_services/models/tls_service_profiles_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TLSServiceProfilesListResponse(BaseModel):
+ """
+ TLSServiceProfilesListResponse
+ """ # noqa: E501
+ data: List[TlsServiceProfiles]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TLSServiceProfilesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TLSServiceProfilesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = TlsServiceProfiles.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [TlsServiceProfiles.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/tls_service_profiles_protocol_settings.py b/scm/identity_services/models/tls_service_profiles_protocol_settings.py
new file mode 100644
index 00000000..9f43f7a2
--- /dev/null
+++ b/scm/identity_services/models/tls_service_profiles_protocol_settings.py
@@ -0,0 +1,130 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TlsServiceProfilesProtocolSettings(BaseModel):
+ """
+ Protocol settings
+ """ # noqa: E501
+ auth_algo_sha1: Optional[StrictBool] = Field(default=None, description="Allow SHA1 authentication?")
+ auth_algo_sha256: Optional[StrictBool] = Field(default=None, description="Allow SHA256 authentication?")
+ auth_algo_sha384: Optional[StrictBool] = Field(default=None, description="Allow SHA384 authentication?")
+ enc_algo_aes_128_cbc: Optional[StrictBool] = Field(default=None, description="Allow AES-128-CBC algorithm?")
+ enc_algo_aes_128_gcm: Optional[StrictBool] = Field(default=None, description="Allow AES-128-GCM algorithm?")
+ enc_algo_aes_256_cbc: Optional[StrictBool] = Field(default=None, description="Allow AES-256-CBC algorithm?")
+ enc_algo_aes_256_gcm: Optional[StrictBool] = Field(default=None, description="Allow algorithm AES-256-GCM")
+ keyxchg_algo_dhe: Optional[StrictBool] = Field(default=None, description="Allow DHE algorithm?")
+ keyxchg_algo_ecdhe: Optional[StrictBool] = Field(default=None, description="Allow ECDHE algorithm?")
+ keyxchg_algo_rsa: Optional[StrictBool] = Field(default=None, description="Allow RSA algorithm?")
+ max_version: Optional[StrictStr] = Field(default=None, description="Maximum TLS version")
+ min_version: Optional[StrictStr] = Field(default=None, description="Minimum TLS version")
+ __properties: ClassVar[List[str]] = ["auth_algo_sha1", "auth_algo_sha256", "auth_algo_sha384", "enc_algo_aes_128_cbc", "enc_algo_aes_128_gcm", "enc_algo_aes_256_cbc", "enc_algo_aes_256_gcm", "keyxchg_algo_dhe", "keyxchg_algo_ecdhe", "keyxchg_algo_rsa", "max_version", "min_version"]
+
+ @field_validator('max_version')
+ def max_version_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['tls1-0', 'tls1-1', 'tls1-2', 'tls1-3']):
+ raise ValueError("must be one of enum values ('tls1-0', 'tls1-1', 'tls1-2', 'tls1-3')")
+ return value
+
+ @field_validator('min_version')
+ def min_version_validate_enum(cls, value):
+ """Validates the enum"""
+ if value is None:
+ return value
+
+ if value not in set(['tls1-0', 'tls1-1', 'tls1-2', 'tls1-3']):
+ raise ValueError("must be one of enum values ('tls1-0', 'tls1-1', 'tls1-2', 'tls1-3')")
+ return value
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TlsServiceProfilesProtocolSettings from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TlsServiceProfilesProtocolSettings from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "auth_algo_sha1": obj.get("auth_algo_sha1"),
+ "auth_algo_sha256": obj.get("auth_algo_sha256"),
+ "auth_algo_sha384": obj.get("auth_algo_sha384"),
+ "enc_algo_aes_128_cbc": obj.get("enc_algo_aes_128_cbc"),
+ "enc_algo_aes_128_gcm": obj.get("enc_algo_aes_128_gcm"),
+ "enc_algo_aes_256_cbc": obj.get("enc_algo_aes_256_cbc"),
+ "enc_algo_aes_256_gcm": obj.get("enc_algo_aes_256_gcm"),
+ "keyxchg_algo_dhe": obj.get("keyxchg_algo_dhe"),
+ "keyxchg_algo_ecdhe": obj.get("keyxchg_algo_ecdhe"),
+ "keyxchg_algo_rsa": obj.get("keyxchg_algo_rsa"),
+ "max_version": obj.get("max_version"),
+ "min_version": obj.get("min_version")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/trusted_certificate_authorities.py b/scm/identity_services/models/trusted_certificate_authorities.py
new file mode 100644
index 00000000..441178c4
--- /dev/null
+++ b/scm/identity_services/models/trusted_certificate_authorities.py
@@ -0,0 +1,109 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrustedCertificateAuthorities(BaseModel):
+ """
+ TrustedCertificateAuthorities
+ """ # noqa: E501
+ common_name: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The trusted certificate authority common name")
+ expiry_epoch: Optional[StrictStr] = None
+ filename: Optional[StrictStr] = Field(default=None, description="Certificate filename")
+ id: Optional[StrictStr] = Field(default=None, description="The UUID of the trusted certificate authority")
+ issuer: Optional[StrictStr] = Field(default=None, description="Issuer")
+ name: Optional[Annotated[str, Field(strict=True, max_length=255)]] = Field(default=None, description="The trusted certificate authority name")
+ not_valid_after: Optional[StrictStr] = Field(default=None, description="Not valid after this date")
+ not_valid_before: Optional[StrictStr] = Field(default=None, description="Not valid before this date")
+ serial_number: Optional[StrictStr] = Field(default=None, description="Serial number")
+ subject: Optional[StrictStr] = Field(default=None, description="Subject")
+ __properties: ClassVar[List[str]] = ["common_name", "expiry_epoch", "filename", "id", "issuer", "name", "not_valid_after", "not_valid_before", "serial_number", "subject"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrustedCertificateAuthorities from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ * OpenAPI `readOnly` fields are excluded.
+ """
+ excluded_fields: Set[str] = set([
+ "id",
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrustedCertificateAuthorities from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ _obj = cls.model_validate({
+ "common_name": obj.get("common_name"),
+ "expiry_epoch": obj.get("expiry_epoch"),
+ "filename": obj.get("filename"),
+ "id": obj.get("id"),
+ "issuer": obj.get("issuer"),
+ "name": obj.get("name"),
+ "not_valid_after": obj.get("not_valid_after"),
+ "not_valid_before": obj.get("not_valid_before"),
+ "serial_number": obj.get("serial_number"),
+ "subject": obj.get("subject")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/models/trusted_certificate_authorities_list_response.py b/scm/identity_services/models/trusted_certificate_authorities_list_response.py
new file mode 100644
index 00000000..d3b9b7e1
--- /dev/null
+++ b/scm/identity_services/models/trusted_certificate_authorities_list_response.py
@@ -0,0 +1,113 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List
+from scm.identity_services.models.trusted_certificate_authorities import TrustedCertificateAuthorities
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TrustedCertificateAuthoritiesListResponse(BaseModel):
+ """
+ TrustedCertificateAuthoritiesListResponse
+ """ # noqa: E501
+ data: List[TrustedCertificateAuthorities]
+ limit: StrictInt = Field(description="The maximum number of results per page")
+ offset: StrictInt = Field(description="The offset into the list of results returned")
+ total: StrictInt = Field(description="The total count of results")
+ __properties: ClassVar[List[str]] = ["data", "limit", "offset", "total"]
+
+ model_config = ConfigDict(
+ populate_by_name=True,
+ validate_assignment=True,
+ protected_namespaces=(),
+ )
+
+
+ def to_str(self) -> str:
+ """Returns the string representation of the model using alias"""
+ return pprint.pformat(self.model_dump(by_alias=True))
+
+ def to_json(self) -> str:
+ """Returns the JSON representation of the model using alias"""
+ # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+ return json.dumps(self.to_dict())
+
+ @classmethod
+ def from_json(cls, json_str: str) -> Optional[Self]:
+ """Create an instance of TrustedCertificateAuthoritiesListResponse from a JSON string"""
+ return cls.from_dict(json.loads(json_str))
+
+ def to_dict(self) -> Dict[str, Any]:
+ """Return the dictionary representation of the model using alias.
+
+ This has the following differences from calling pydantic's
+ `self.model_dump(by_alias=True)`:
+
+ * `None` is only added to the output dict for nullable fields that
+ were set at model initialization. Other fields with value `None`
+ are ignored.
+ """
+ excluded_fields: Set[str] = set([
+ ])
+
+ _dict = self.model_dump(
+ by_alias=True,
+ exclude=excluded_fields,
+ exclude_none=True,
+ )
+ # override the default output from pydantic by calling `to_dict()` of each item in data (list)
+ _items = []
+ if self.data:
+ for _item_data in self.data:
+ if _item_data:
+ _items.append(_item_data.to_dict())
+ _dict['data'] = _items
+ return _dict
+
+ @classmethod
+ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+ """Create an instance of TrustedCertificateAuthoritiesListResponse from a dict"""
+ if obj is None:
+ return None
+
+ if not isinstance(obj, dict):
+ return cls.model_validate(obj)
+
+ # Detect bare object response (API returns single object instead of paginated list)
+ # This happens when server-side name filtering returns exactly one result
+ if "data" not in obj and "total" not in obj:
+ single_obj = TrustedCertificateAuthorities.from_dict(obj)
+ return cls.model_validate({
+ "data": [single_obj] if single_obj is not None else [],
+ "limit": 1,
+ "offset": 0,
+ "total": 1 if single_obj is not None else 0,
+ })
+
+ _obj = cls.model_validate({
+ "data": [TrustedCertificateAuthorities.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+ "limit": obj.get("limit") if obj.get("limit") is not None else 200,
+ "offset": obj.get("offset") if obj.get("offset") is not None else 0,
+ "total": obj.get("total")
+ })
+ return _obj
+
+
diff --git a/scm/identity_services/rest.py b/scm/identity_services/rest.py
new file mode 100644
index 00000000..55263136
--- /dev/null
+++ b/scm/identity_services/rest.py
@@ -0,0 +1,258 @@
+# coding: utf-8
+
+"""
+ Identity Services
+
+ These APIs are used for defining and managing identity services configurations within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import io
+import json
+import re
+import ssl
+
+import urllib3
+
+from scm.identity_services.exceptions import ApiException, ApiValueError
+
+SUPPORTED_SOCKS_PROXIES = {"socks5", "socks5h", "socks4", "socks4a"}
+RESTResponseType = urllib3.HTTPResponse
+
+
+def is_socks_proxy_url(url):
+ if url is None:
+ return False
+ split_section = url.split("://")
+ if len(split_section) < 2:
+ return False
+ else:
+ return split_section[0].lower() in SUPPORTED_SOCKS_PROXIES
+
+
+class RESTResponse(io.IOBase):
+
+ def __init__(self, resp) -> None:
+ self.response = resp
+ self.status = resp.status
+ self.reason = resp.reason
+ self.data = None
+
+ def read(self):
+ if self.data is None:
+ self.data = self.response.data
+ return self.data
+
+ def getheaders(self):
+ """Returns a dictionary of the response headers."""
+ return self.response.headers
+
+ def getheader(self, name, default=None):
+ """Returns a given response header."""
+ return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+ def __init__(self, configuration) -> None:
+ # urllib3.PoolManager will pass all kw parameters to connectionpool
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501
+ # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501
+ # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501
+
+ # cert_reqs
+ if configuration.verify_ssl:
+ cert_reqs = ssl.CERT_REQUIRED
+ else:
+ cert_reqs = ssl.CERT_NONE
+
+ pool_args = {
+ "cert_reqs": cert_reqs,
+ "ca_certs": configuration.ssl_ca_cert,
+ "cert_file": configuration.cert_file,
+ "key_file": configuration.key_file,
+ }
+ if configuration.assert_hostname is not None:
+ pool_args['assert_hostname'] = (
+ configuration.assert_hostname
+ )
+
+ if configuration.retries is not None:
+ pool_args['retries'] = configuration.retries
+
+ if configuration.tls_server_name:
+ pool_args['server_hostname'] = configuration.tls_server_name
+
+
+ if configuration.socket_options is not None:
+ pool_args['socket_options'] = configuration.socket_options
+
+ if configuration.connection_pool_maxsize is not None:
+ pool_args['maxsize'] = configuration.connection_pool_maxsize
+
+ # https pool manager
+ self.pool_manager: urllib3.PoolManager
+
+ if configuration.proxy:
+ if is_socks_proxy_url(configuration.proxy):
+ from urllib3.contrib.socks import SOCKSProxyManager
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["headers"] = configuration.proxy_headers
+ self.pool_manager = SOCKSProxyManager(**pool_args)
+ else:
+ pool_args["proxy_url"] = configuration.proxy
+ pool_args["proxy_headers"] = configuration.proxy_headers
+ self.pool_manager = urllib3.ProxyManager(**pool_args)
+ else:
+ self.pool_manager = urllib3.PoolManager(**pool_args)
+
+ def request(
+ self,
+ method,
+ url,
+ headers=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ):
+ """Perform requests.
+
+ :param method: http request method
+ :param url: http request url
+ :param headers: http request headers
+ :param body: request json body, for `application/json`
+ :param post_params: request post parameters,
+ `application/x-www-form-urlencoded`
+ and `multipart/form-data`
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ """
+ method = method.upper()
+ assert method in [
+ 'GET',
+ 'HEAD',
+ 'DELETE',
+ 'POST',
+ 'PUT',
+ 'PATCH',
+ 'OPTIONS'
+ ]
+
+ if post_params and body:
+ raise ApiValueError(
+ "body parameter cannot be used with post_params parameter."
+ )
+
+ post_params = post_params or {}
+ headers = headers or {}
+
+ timeout = None
+ if _request_timeout:
+ if isinstance(_request_timeout, (int, float)):
+ timeout = urllib3.Timeout(total=_request_timeout)
+ elif (
+ isinstance(_request_timeout, tuple)
+ and len(_request_timeout) == 2
+ ):
+ timeout = urllib3.Timeout(
+ connect=_request_timeout[0],
+ read=_request_timeout[1]
+ )
+
+ try:
+ # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+ if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+
+ # no content type provided or payload is json
+ content_type = headers.get('Content-Type')
+ if (
+ not content_type
+ or re.search('json', content_type, re.IGNORECASE)
+ ):
+ request_body = None
+ if body is not None:
+ request_body = json.dumps(body)
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'application/x-www-form-urlencoded':
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=False,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif content_type == 'multipart/form-data':
+ # must del headers['Content-Type'], or the correct
+ # Content-Type which generated by urllib3 will be
+ # overwritten.
+ del headers['Content-Type']
+ # Ensures that dict objects are serialized
+ post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a,b) for a, b in post_params]
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields=post_params,
+ encode_multipart=True,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ # Pass a `string` parameter directly in the body to support
+ # other content types than JSON when `body` argument is
+ # provided in serialized form.
+ elif isinstance(body, str) or isinstance(body, bytes):
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=body,
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ elif headers['Content-Type'].startswith('text/') and isinstance(body, bool):
+ request_body = "true" if body else "false"
+ r = self.pool_manager.request(
+ method,
+ url,
+ body=request_body,
+ preload_content=False,
+ timeout=timeout,
+ headers=headers)
+ else:
+ # Cannot generate the request from given parameters
+ msg = """Cannot prepare a request message for provided
+ arguments. Please check that your arguments match
+ declared content type."""
+ raise ApiException(status=0, reason=msg)
+ # For `GET`, `HEAD`
+ else:
+ r = self.pool_manager.request(
+ method,
+ url,
+ fields={},
+ timeout=timeout,
+ headers=headers,
+ preload_content=False
+ )
+ except urllib3.exceptions.SSLError as e:
+ msg = "\n".join([type(e).__name__, str(e)])
+ raise ApiException(status=0, reason=msg)
+
+ return RESTResponse(r)
diff --git a/scm/identity_services/tests/__init__.py b/scm/identity_services/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/scm/identity_services/tests/api_authentication_portals_test.py b/scm/identity_services/tests/api_authentication_portals_test.py
new file mode 100644
index 00000000..b3a03d4e
--- /dev/null
+++ b/scm/identity_services/tests/api_authentication_portals_test.py
@@ -0,0 +1,253 @@
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.identity_services.models.authentication_portals import AuthenticationPortals
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+TEST_REDIRECT_HOST = "192.168.255.254"
+CERT_PROFILE_NAME = "EDL-Hosting-Service-Profile"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def auth_portals_api(client):
+ return client.identity_services.AuthenticationPortalsApi(client.identity_services.api_client)
+
+
+@pytest.fixture(scope="module")
+def auth_profiles_api(client):
+ return client.identity_services.AuthenticationProfilesApi(client.identity_services.api_client)
+
+
+@pytest.fixture(scope="module")
+def test_auth_profile(auth_profiles_api):
+ """
+ Setup/Teardown for prerequisite Authentication Profile.
+ """
+ profile_name = f"test-auth-prof-{uuid.uuid4().hex[:6]}"
+
+ payload = AuthenticationProfiles(
+ id="",
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ allow_list=["all"],
+ method=AuthenticationProfilesMethod(local_database={})
+ )
+
+ logger.info(f"\n[SETUP] Creating Prerequisite Auth Profile: {profile_name}")
+ try:
+ created_profile = perform(
+ auth_profiles_api.create_authentication_profiles_with_http_info,
+ response_type=AuthenticationProfiles,
+ authentication_profiles=payload
+ )
+ except Exception as e:
+ logger.warning(f"Could not create auth profile fixture: {e}")
+ pytest.skip(f"Prerequisite auth profile creation failed: {e}")
+
+ yield created_profile.name
+
+ logger.info(f"\n[TEARDOWN] Deleting Auth Profile: {created_profile.id}")
+ try:
+ perform(
+ auth_profiles_api.delete_authentication_profiles_by_id_with_http_info,
+ id=created_profile.id
+ )
+ except Exception as e:
+ logger.error(f"Failed to cleanup auth profile: {e}")
+
+
+@pytest.fixture
+def clean_auth_portal(auth_portals_api, test_auth_profile):
+ """
+ Setup/Teardown for an Authentication Portal (singleton per folder).
+
+ Tries to create a new portal. If one already exists (OBJECT_ALREADY_EXISTS),
+ fetches the existing one instead. Only deletes on teardown if we created it.
+ """
+ from scm.exceptions import NameNotUniqueError
+
+ created_by_us = False
+ portal = None
+
+ payload = AuthenticationPortals(
+ folder=TARGET_FOLDER,
+ redirect_host=TEST_REDIRECT_HOST,
+ authentication_profile=test_auth_profile,
+ certificate_profile=CERT_PROFILE_NAME,
+ gp_udp_port=10,
+ idle_timer=10,
+ timer=12
+ )
+
+ try:
+ logger.info(f"\n[SETUP] Attempting to create Auth Portal")
+ portal = perform(
+ auth_portals_api.create_authentication_portals_with_http_info,
+ response_type=AuthenticationPortals,
+ authentication_portals=payload
+ )
+ created_by_us = True
+ logger.info(f"[SETUP] Created Auth Portal: {portal.id}")
+ except NameNotUniqueError:
+ logger.info("[SETUP] Portal already exists (singleton), fetching existing one")
+ response = auth_portals_api.list_authentication_portals(folder=TARGET_FOLDER)
+ assert response is not None and response.data and len(response.data) > 0, \
+ "Portal reported as existing but list returned empty"
+ portal = response.data[0]
+ logger.info(f"[SETUP] Using existing Auth Portal: {portal.id}")
+
+ yield portal
+
+ if created_by_us and portal:
+ logger.info(f"\n[TEARDOWN] Deleting Auth Portal: {portal.id}")
+ try:
+ perform(
+ auth_portals_api.delete_authentication_portals_by_id_with_http_info,
+ id=portal.id
+ )
+ except Exception as e:
+ logger.error(f"Failed to cleanup auth portal: {e}")
+ else:
+ logger.info("\n[TEARDOWN] Skipping delete (portal was pre-existing)")
+
+
+def test_create_auth_portal(auth_portals_api, test_auth_profile):
+ """Test creation of an Authentication Portal (singleton — accepts already exists)."""
+ from scm.exceptions import NameNotUniqueError
+
+ payload = AuthenticationPortals(
+ folder=TARGET_FOLDER,
+ redirect_host=TEST_REDIRECT_HOST,
+ authentication_profile=test_auth_profile,
+ certificate_profile=CERT_PROFILE_NAME,
+ gp_udp_port=10,
+ idle_timer=10,
+ timer=12
+ )
+
+ try:
+ created_obj = perform(
+ auth_portals_api.create_authentication_portals_with_http_info,
+ response_type=AuthenticationPortals,
+ authentication_portals=payload
+ )
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.redirect_host == TEST_REDIRECT_HOST
+ logger.info(f"Created new Auth Portal: {created_obj.id}")
+
+ perform(
+ auth_portals_api.delete_authentication_portals_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except NameNotUniqueError:
+ logger.info("Auth Portal already exists (singleton) — verifying via list")
+ response = auth_portals_api.list_authentication_portals(folder=TARGET_FOLDER)
+ assert response is not None and response.data and len(response.data) > 0
+ logger.info(f"Verified existing Auth Portal: {response.data[0].id}")
+
+
+def test_get_auth_portal_by_id(auth_portals_api, clean_auth_portal):
+ """Test retrieving an Authentication Portal by ID."""
+ fetched_obj = perform(
+ auth_portals_api.get_authentication_portals_by_id_with_http_info,
+ id=clean_auth_portal.id
+ )
+
+ assert fetched_obj.id == clean_auth_portal.id
+ assert fetched_obj.redirect_host is not None
+
+
+def test_update_auth_portal(auth_portals_api, clean_auth_portal):
+ """Test updating an Authentication Portal."""
+ update_payload = clean_auth_portal
+ update_payload.gp_udp_port = 20
+ update_payload.timer = 30
+
+ updated_obj = perform(
+ auth_portals_api.update_authentication_portals_by_id_with_http_info,
+ id=clean_auth_portal.id,
+ authentication_portals=update_payload
+ )
+
+ assert updated_obj.id == clean_auth_portal.id
+ assert updated_obj.gp_udp_port == 20
+ assert updated_obj.timer == 30
+
+
+def test_list_auth_portals(auth_portals_api, clean_auth_portal):
+ """Test listing Authentication Portals."""
+ response = auth_portals_api.list_authentication_portals(folder=TARGET_FOLDER)
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.id == clean_auth_portal.id:
+ found = True
+ break
+ assert found is True, f"Portal {clean_auth_portal.id} not found in list response"
+
+
+def test_delete_auth_portal(auth_portals_api, test_auth_profile):
+ """
+ Test deleting an Authentication Portal by ID.
+ Equivalent to Go: Test_identityservices_AuthenticationPortalsAPIService__DeleteByID
+ """
+ from scm.exceptions import NameNotUniqueError
+
+ # Create a portal to delete
+ payload = AuthenticationPortals(
+ folder=TARGET_FOLDER,
+ redirect_host=TEST_REDIRECT_HOST,
+ authentication_profile=test_auth_profile,
+ certificate_profile=CERT_PROFILE_NAME,
+ gp_udp_port=10,
+ idle_timer=10,
+ timer=12
+ )
+
+ try:
+ portal = perform(
+ auth_portals_api.create_authentication_portals_with_http_info,
+ response_type=AuthenticationPortals,
+ authentication_portals=payload
+ )
+ logger.info(f"Created Auth Portal for delete test: {portal.id}")
+ except NameNotUniqueError:
+ # Singleton — use existing portal
+ response = auth_portals_api.list_authentication_portals(folder=TARGET_FOLDER)
+ assert response is not None and response.data and len(response.data) > 0
+ portal = response.data[0]
+ logger.info(f"Using existing Auth Portal for delete test: {portal.id}")
+
+ assert portal is not None
+ portal_id = portal.id
+
+ # Delete the portal
+ perform(
+ auth_portals_api.delete_authentication_portals_by_id_with_http_info,
+ id=portal_id
+ )
+ logger.info(f"Successfully deleted Auth Portal: {portal_id}")
diff --git a/scm/identity_services/tests/api_authentication_profiles_test.py b/scm/identity_services/tests/api_authentication_profiles_test.py
new file mode 100644
index 00000000..65bdf3e8
--- /dev/null
+++ b/scm/identity_services/tests/api_authentication_profiles_test.py
@@ -0,0 +1,274 @@
+import logging
+import uuid
+import json
+import pytest
+from scm import Scm
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+from scm.identity_services.models.authentication_profiles_lockout import AuthenticationProfilesLockout
+from scm.identity_services.models.authentication_profiles_single_sign_on import AuthenticationProfilesSingleSignOn
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def auth_profiles_api(client):
+ """
+ Fixture to return the Authentication Profiles API instance.
+ """
+ return client.identity_services.AuthenticationProfilesApi(client.identity_services.api_client)
+
+@pytest.fixture
+def clean_auth_profile(auth_profiles_api):
+ """
+ Fixture to create a temporary Authentication Profile for testing and automatically delete it after.
+ """
+ profile_name = f"test-auth-prof-{uuid.uuid4().hex[:6]}"
+
+ # Create method with local database
+ method = AuthenticationProfilesMethod(
+ local_database={}
+ )
+
+ # Create lockout settings
+ lockout = AuthenticationProfilesLockout(
+ failed_attempts=9,
+ lockout_time=5
+ )
+
+ # Create single sign-on settings
+ sso = AuthenticationProfilesSingleSignOn(
+ realm="EXAMPLE.COM"
+ )
+
+ payload = AuthenticationProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ allow_list=["all"],
+ method=method,
+ lockout=lockout,
+ single_sign_on=sso,
+ user_domain="default",
+ username_modifier="%USERINPUT%"
+ )
+
+ logger.info(f"\n[SETUP] Creating Authentication Profile: {profile_name}")
+ created_obj = perform(
+ auth_profiles_api.create_authentication_profiles_with_http_info,
+ response_type=AuthenticationProfiles,
+ authentication_profiles=payload
+ )
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting Authentication Profile ID: {created_obj.id}")
+ try:
+ perform(
+ auth_profiles_api.delete_authentication_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed: {e}")
+
+
+def test_create_auth_profile(auth_profiles_api):
+ """
+ Test manual creation and deletion of an Authentication Profile with logging.
+ Mirrors Test_identityservices_AuthenticationProfilesAPIService__CreateLocalDB_Full
+ """
+ profile_name = f"test-auth-create-{uuid.uuid4().hex[:6]}"
+
+ # Create method with local database
+ method = AuthenticationProfilesMethod(
+ local_database={}
+ )
+
+ # Create lockout settings
+ lockout = AuthenticationProfilesLockout(
+ failed_attempts=9,
+ lockout_time=5
+ )
+
+ # Create single sign-on settings
+ sso = AuthenticationProfilesSingleSignOn(
+ realm="EXAMPLE.COM"
+ )
+
+ payload = AuthenticationProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ allow_list=["all"],
+ method=method,
+ lockout=lockout,
+ single_sign_on=sso,
+ user_domain="default",
+ username_modifier="%USERINPUT%"
+ )
+
+ # Create with logging
+ created_obj = perform(
+ auth_profiles_api.create_authentication_profiles_with_http_info,
+ response_type=AuthenticationProfiles,
+ authentication_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == profile_name
+ assert created_obj.user_domain == "default"
+ assert created_obj.username_modifier == "%USERINPUT%"
+ assert "all" in created_obj.allow_list
+ assert created_obj.lockout.failed_attempts == 9
+ assert created_obj.lockout.lockout_time == 5
+ assert created_obj.single_sign_on.realm == "EXAMPLE.COM"
+
+ # Cleanup with logging
+ perform(
+ auth_profiles_api.delete_authentication_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_auth_profile_by_id(auth_profiles_api, clean_auth_profile):
+ """
+ Test retrieving an Authentication Profile by ID with logging.
+ Mirrors Test_identityservices_AuthenticationProfilesAPIService__GetByID
+ """
+ fetched_obj = perform(
+ auth_profiles_api.get_authentication_profiles_by_id_with_http_info,
+ id=clean_auth_profile.id
+ )
+
+ assert fetched_obj.id == clean_auth_profile.id
+ assert fetched_obj.name == clean_auth_profile.name
+
+
+def test_update_auth_profile(auth_profiles_api, clean_auth_profile):
+ """
+ Test updating an Authentication Profile with logging.
+ Mirrors Test_identityservices_AuthenticationProfilesAPIService__UpdateLocalDB
+ """
+ update_payload = clean_auth_profile
+ update_payload.user_domain = "paloaltonetworks.com"
+
+ updated_obj = perform(
+ auth_profiles_api.update_authentication_profiles_by_id_with_http_info,
+ id=clean_auth_profile.id,
+ authentication_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_auth_profile.id
+ assert updated_obj.user_domain == "paloaltonetworks.com"
+
+
+def test_list_auth_profiles(auth_profiles_api, clean_auth_profile):
+ """
+ Test listing Authentication Profiles with logging.
+ """
+ response = perform(
+ auth_profiles_api.list_authentication_profiles_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ # Verify the fixture object is in the list
+ found = False
+ for item in response.data:
+ if item.id == clean_auth_profile.id:
+ found = True
+ break
+ assert found is True, f"Created profile {clean_auth_profile.id} not found in list response"
+
+
+
+
+def test_fetch_authentication_profiles(auth_profiles_api, clean_auth_profile):
+ """
+ Test fetching a single authentication_profiles by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = auth_profiles_api.fetch_authentication_profiles(
+ name=clean_auth_profile.name,
+ folder=clean_auth_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found authentication_profiles '{clean_auth_profile.name}'"
+ assert fetched_obj.id == clean_auth_profile.id
+ assert fetched_obj.name == clean_auth_profile.name
+ assert fetched_obj.folder == clean_auth_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_authentication_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent authentication_profiles (should return None)
+ not_found = auth_profiles_api.fetch_authentication_profiles(
+ name="non-existent-authentication_profiles-xyz-12345",
+ folder=clean_auth_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent authentication_profiles"
+ logger.info(f"\n[SUCCESS] fetch_authentication_profiles correctly returned None for non-existent authentication_profiles")
+
+
+def test_delete_auth_profile_by_id(auth_profiles_api):
+ """
+ Test deletion specifically with logging.
+ """
+ # Setup
+ profile_name = f"test-auth-del-{uuid.uuid4().hex[:6]}"
+
+ method = AuthenticationProfilesMethod(
+ local_database={}
+ )
+
+ payload = AuthenticationProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ allow_list=["all"],
+ method=method
+ )
+
+ created_obj = perform(
+ auth_profiles_api.create_authentication_profiles_with_http_info,
+ response_type=AuthenticationProfiles,
+ authentication_profiles=payload
+ )
+
+ # Perform Delete with logging
+ perform(
+ auth_profiles_api.delete_authentication_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ # Verify Deletion
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ auth_profiles_api.get_authentication_profiles_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_authentication_rules_test.py b/scm/identity_services/tests/api_authentication_rules_test.py
new file mode 100644
index 00000000..49b5ac8b
--- /dev/null
+++ b/scm/identity_services/tests/api_authentication_rules_test.py
@@ -0,0 +1,233 @@
+import logging
+import uuid
+import json
+import pytest
+from scm import Scm
+from scm.identity_services.models.authentication_rules import AuthenticationRules
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def auth_rules_api(client):
+ return client.identity_services.AuthenticationRulesApi(client.identity_services.api_client)
+
+@pytest.fixture(scope="module")
+def auth_profiles_api(client):
+ return client.identity_services.AuthenticationProfilesApi(client.identity_services.api_client)
+
+@pytest.fixture(scope="module")
+def test_auth_profile(auth_profiles_api):
+ """
+ Setup/Teardown for the prerequisite Authentication Profile.
+ """
+ profile_name = f"scm-authprofile-{uuid.uuid4().hex[:4]}"
+
+ method = AuthenticationProfilesMethod(
+ local_database={}
+ )
+
+ payload = AuthenticationProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ allow_list=["all"],
+ method=method
+ )
+
+ logger.info(f"\n[SETUP] Creating Prerequisite Auth Profile: {profile_name}")
+ created_profile = perform(
+ auth_profiles_api.create_authentication_profiles_with_http_info,
+ response_type=AuthenticationProfiles,
+ authentication_profiles=payload
+ )
+
+ yield created_profile.name
+
+ logger.info(f"\n[TEARDOWN] Deleting Auth Profile: {created_profile.name}")
+ try:
+ perform(
+ auth_profiles_api.delete_authentication_profiles_by_id_with_http_info,
+ id=created_profile.id
+ )
+ except Exception as e:
+ logger.error(f"Failed to cleanup auth profile: {e}")
+
+@pytest.fixture
+def clean_auth_rule(auth_rules_api, test_auth_profile):
+ rule_name = f"test-auth-rule-{uuid.uuid4().hex[:6]}"
+
+ payload = AuthenticationRules(
+ name=rule_name,
+ folder=TARGET_FOLDER,
+ destination=["any"],
+ var_from=["any"],
+ service=["any"],
+ source=["any"],
+ to=["any"],
+ authentication_enforcement=test_auth_profile,
+ timeout=1000,
+ description="Test rule for Auth Rule CRUD",
+ log_authentication_timeout=True
+ )
+
+ logger.info(f"\n[SETUP] Creating Authentication Rule: {rule_name}")
+ created_obj = perform(
+ auth_rules_api.create_authentication_rules_with_http_info,
+ response_type=AuthenticationRules,
+ authentication_rules=payload,
+ position="pre"
+ )
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting Authentication Rule ID: {created_obj.id}")
+ try:
+ perform(
+ auth_rules_api.delete_authentication_rules_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed: {e}")
+
+
+def test_create_auth_rule(auth_rules_api, test_auth_profile):
+ rule_name = f"test-auth-create-{uuid.uuid4().hex[:6]}"
+
+ payload = AuthenticationRules(
+ name=rule_name,
+ folder=TARGET_FOLDER,
+ destination=["any"],
+ var_from=["any"],
+ service=["any"],
+ source=["any"],
+ to=["any"],
+ authentication_enforcement=test_auth_profile,
+ timeout=1000,
+ description="Test rule for Auth Rule CRUD",
+ log_authentication_timeout=True
+ )
+
+ created_obj = perform(
+ auth_rules_api.create_authentication_rules_with_http_info,
+ response_type=AuthenticationRules,
+ authentication_rules=payload,
+ position="pre"
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == rule_name
+ assert created_obj.timeout == 1000
+
+ perform(
+ auth_rules_api.delete_authentication_rules_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_auth_rule_by_id(auth_rules_api, clean_auth_rule):
+ fetched_obj = perform(
+ auth_rules_api.get_authentication_rules_by_id_with_http_info,
+ id=clean_auth_rule.id
+ )
+
+ assert fetched_obj.id == clean_auth_rule.id
+ assert fetched_obj.name == clean_auth_rule.name
+ assert fetched_obj.service == ["any"]
+
+
+def test_update_auth_rule(auth_rules_api, clean_auth_rule):
+ update_payload = clean_auth_rule
+ update_payload.timeout = 900
+ update_payload.description = "Updated auth rule description"
+
+ updated_obj = perform(
+ auth_rules_api.update_authentication_rules_by_id_with_http_info,
+ id=clean_auth_rule.id,
+ authentication_rules=update_payload
+ )
+
+ assert updated_obj.id == clean_auth_rule.id
+ assert updated_obj.timeout == 900
+ assert updated_obj.description == "Updated auth rule description"
+
+
+def test_list_auth_rules(auth_rules_api, clean_auth_rule):
+ """Test listing Authentication Rules filtered by name to avoid system rules with null fields."""
+ response = perform(
+ auth_rules_api.list_authentication_rules_with_http_info,
+ folder=TARGET_FOLDER,
+ position="pre",
+ name=clean_auth_rule.name,
+ limit=10,
+ offset=0
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.id == clean_auth_rule.id:
+ found = True
+ break
+ assert found is True, f"Created rule {clean_auth_rule.id} not found in list response"
+
+
+
+def test_delete_auth_rule_by_id(auth_rules_api, test_auth_profile):
+ rule_name = f"test-auth-del-{uuid.uuid4().hex[:6]}"
+
+ payload = AuthenticationRules(
+ name=rule_name,
+ folder=TARGET_FOLDER,
+ destination=["any"],
+ var_from=["any"],
+ service=["any"],
+ source=["any"],
+ to=["any"],
+ authentication_enforcement=test_auth_profile,
+ timeout=1000
+ )
+
+ created_obj = perform(
+ auth_rules_api.create_authentication_rules_with_http_info,
+ response_type=AuthenticationRules,
+ authentication_rules=payload,
+ position="pre"
+ )
+
+ perform(
+ auth_rules_api.delete_authentication_rules_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ auth_rules_api.get_authentication_rules_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Rule should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_authentication_sequences_test.py b/scm/identity_services/tests/api_authentication_sequences_test.py
new file mode 100644
index 00000000..25e1b9ed
--- /dev/null
+++ b/scm/identity_services/tests/api_authentication_sequences_test.py
@@ -0,0 +1,255 @@
+import logging
+import uuid
+import json
+import pytest
+from scm import Scm
+from scm.identity_services.models.authentication_sequences import AuthenticationSequences
+from scm.identity_services.models.authentication_profiles import AuthenticationProfiles
+from scm.identity_services.models.authentication_profiles_method import AuthenticationProfilesMethod
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def auth_sequences_api(client):
+ return client.identity_services.AuthenticationSequencesApi(client.identity_services.api_client)
+
+@pytest.fixture(scope="module")
+def auth_profiles_api(client):
+ return client.identity_services.AuthenticationProfilesApi(client.identity_services.api_client)
+
+@pytest.fixture(scope="module")
+def test_auth_profile(auth_profiles_api):
+ """
+ Setup/Teardown for the prerequisite Authentication Profile.
+ """
+ profile_name = f"scm-authprofile-{uuid.uuid4().hex[:4]}"
+
+ method = AuthenticationProfilesMethod(
+ local_database={}
+ )
+
+ payload = AuthenticationProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ allow_list=["all"],
+ method=method
+ )
+
+ logger.info(f"\n[SETUP] Creating Prerequisite Auth Profile: {profile_name}")
+ created_profile = perform(
+ auth_profiles_api.create_authentication_profiles_with_http_info,
+ response_type=AuthenticationProfiles,
+ authentication_profiles=payload
+ )
+
+ yield created_profile.name
+
+ logger.info(f"\n[TEARDOWN] Deleting Auth Profile: {created_profile.name}")
+ try:
+ perform(
+ auth_profiles_api.delete_authentication_profiles_by_id_with_http_info,
+ id=created_profile.id
+ )
+ except Exception as e:
+ logger.error(f"Failed to cleanup auth profile: {e}")
+
+@pytest.fixture
+def clean_auth_sequence(auth_sequences_api, test_auth_profile):
+ """
+ Creates an Authentication Sequence for tests that require an existing object.
+ """
+ sequence_name = f"test-auth-seq-{uuid.uuid4().hex[:6]}"
+
+ payload = AuthenticationSequences(
+ name=sequence_name,
+ folder=TARGET_FOLDER,
+ authentication_profiles=[test_auth_profile],
+ use_domain_find_profile=False
+ )
+
+ logger.info(f"\n[SETUP] Creating Authentication Sequence: {sequence_name}")
+ created_obj = perform(
+ auth_sequences_api.create_authentication_sequences_with_http_info,
+ response_type=AuthenticationSequences,
+ authentication_sequences=payload
+ )
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting Authentication Sequence ID: {created_obj.id}")
+ try:
+ perform(
+ auth_sequences_api.delete_authentication_sequences_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed: {e}")
+
+
+def test_create_auth_sequence(auth_sequences_api, test_auth_profile):
+ """
+ Test manual creation and deletion of an Authentication Sequence with logging.
+ Mirrors Test_identityservices_AuthenticationSequencesAPIService__Create
+ """
+ sequence_name = f"test-auth-seq-create-{uuid.uuid4().hex[:6]}"
+
+ payload = AuthenticationSequences(
+ name=sequence_name,
+ folder=TARGET_FOLDER,
+ authentication_profiles=[test_auth_profile],
+ use_domain_find_profile=False
+ )
+
+ created_obj = perform(
+ auth_sequences_api.create_authentication_sequences_with_http_info,
+ response_type=AuthenticationSequences,
+ authentication_sequences=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == sequence_name
+ assert created_obj.use_domain_find_profile == False
+ assert created_obj.authentication_profiles == [test_auth_profile]
+
+ perform(
+ auth_sequences_api.delete_authentication_sequences_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_auth_sequence_by_id(auth_sequences_api, clean_auth_sequence):
+ """
+ Test retrieving an Authentication Sequence by ID with logging.
+ Mirrors Test_identityservices_AuthenticationSequencesAPIService__GetByID
+ """
+ fetched_obj = perform(
+ auth_sequences_api.get_authentication_sequences_by_id_with_http_info,
+ id=clean_auth_sequence.id
+ )
+
+ assert fetched_obj.id == clean_auth_sequence.id
+ assert fetched_obj.name == clean_auth_sequence.name
+
+
+def test_update_auth_sequence(auth_sequences_api, clean_auth_sequence):
+ """
+ Test updating an Authentication Sequence with logging.
+ Mirrors Test_identityservices_AuthenticationSequencesAPIService__Update
+ """
+ update_payload = clean_auth_sequence
+ update_payload.use_domain_find_profile = True
+
+ updated_obj = perform(
+ auth_sequences_api.update_authentication_sequences_by_id_with_http_info,
+ id=clean_auth_sequence.id,
+ authentication_sequences=update_payload
+ )
+
+ assert updated_obj.id == clean_auth_sequence.id
+ assert updated_obj.use_domain_find_profile == True
+
+
+def test_list_auth_sequences(auth_sequences_api, clean_auth_sequence):
+ """
+ Test listing Authentication Sequences with logging.
+ Mirrors Test_identityservices_AuthenticationSequencesAPIService__List
+ """
+ response = perform(
+ auth_sequences_api.list_authentication_sequences_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.id == clean_auth_sequence.id:
+ found = True
+ break
+ assert found is True, f"Created sequence {clean_auth_sequence.id} not found in list response"
+
+
+
+
+def test_fetch_authentication_sequences(auth_sequences_api, clean_auth_sequence):
+ """
+ Test fetching a single authentication_sequences by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = auth_sequences_api.fetch_authentication_sequences(
+ name=clean_auth_sequence.name,
+ folder=clean_auth_sequence.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found authentication_sequences '{clean_auth_sequence.name}'"
+ assert fetched_obj.id == clean_auth_sequence.id
+ assert fetched_obj.name == clean_auth_sequence.name
+ assert fetched_obj.folder == clean_auth_sequence.folder
+ logger.info(f"\n[SUCCESS] fetch_authentication_sequences found object: {fetched_obj.name}")
+
+ # Test fetching non-existent authentication_sequences (should return None)
+ not_found = auth_sequences_api.fetch_authentication_sequences(
+ name="non-existent-authentication_sequences-xyz-12345",
+ folder=clean_auth_sequence.folder
+ )
+ assert not_found is None, "Should return None for non-existent authentication_sequences"
+ logger.info(f"\n[SUCCESS] fetch_authentication_sequences correctly returned None for non-existent authentication_sequences")
+
+
+def test_delete_auth_sequence_by_id(auth_sequences_api, test_auth_profile):
+ """
+ Test deletion specifically with logging.
+ Mirrors Test_identityservices_AuthenticationSequencesAPIService__DeleteByID
+ """
+ sequence_name = f"test-auth-seq-del-{uuid.uuid4().hex[:6]}"
+
+ payload = AuthenticationSequences(
+ name=sequence_name,
+ folder=TARGET_FOLDER,
+ authentication_profiles=[test_auth_profile],
+ use_domain_find_profile=False
+ )
+
+ created_obj = perform(
+ auth_sequences_api.create_authentication_sequences_with_http_info,
+ response_type=AuthenticationSequences,
+ authentication_sequences=payload
+ )
+
+ perform(
+ auth_sequences_api.delete_authentication_sequences_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ auth_sequences_api.get_authentication_sequences_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Sequence should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_certificate_profiles_test.py b/scm/identity_services/tests/api_certificate_profiles_test.py
new file mode 100644
index 00000000..6e2ad4ed
--- /dev/null
+++ b/scm/identity_services/tests/api_certificate_profiles_test.py
@@ -0,0 +1,282 @@
+import logging
+import uuid
+import json
+import pytest
+from scm import Scm
+from scm.identity_services.models.certificate_profiles import CertificateProfiles
+from scm.identity_services.models.certificate_profiles_ca_certificates_inner import CertificateProfilesCaCertificatesInner
+from scm.identity_services.models.certificate_profiles_username_field import CertificateProfilesUsernameField
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "Shared"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def cert_profiles_api(client):
+ """
+ Fixture to return the Certificate Profiles API instance.
+ """
+ return client.identity_services.CertificateProfilesApi(client.identity_services.api_client)
+
+@pytest.fixture
+def clean_cert_profile(cert_profiles_api):
+ """
+ Fixture to create a temporary Certificate Profile for testing and automatically delete it after.
+ """
+ # Create a profile with all fields for comprehensive testing
+ profile_name = f"test-cert-prof-{uuid.uuid4().hex[:6]}"
+
+ ca_cert = CertificateProfilesCaCertificatesInner(
+ name="Forward-Trust-CA",
+ default_ocsp_url="http://test.com",
+ )
+
+ username_field = CertificateProfilesUsernameField(
+ subject="common-name"
+ )
+
+ payload = CertificateProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ ca_certificates=[ca_cert],
+ domain="test",
+ use_crl=True,
+ use_ocsp=True,
+ block_unknown_cert=True,
+ block_timeout_cert=True,
+ block_unauthenticated_cert=True,
+ block_expired_cert=True,
+ username_field=username_field,
+ crl_receive_timeout="5",
+ ocsp_receive_timeout="5",
+ cert_status_timeout="5"
+ )
+
+ logger.info(f"\n[SETUP] Creating Certificate Profile: {profile_name}")
+ created_obj = perform(
+ cert_profiles_api.create_certificate_profiles,
+ certificate_profiles=payload
+ )
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting Certificate Profile ID: {created_obj.id}")
+ try:
+ perform(
+ cert_profiles_api.delete_certificate_profiles_by_id,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed: {e}")
+
+
+def test_create_cert_profile(cert_profiles_api):
+ """
+ Test manual creation and deletion of a Certificate Profile with logging.
+ Mirrors Test_identityservices_CertificateProfilesAPIService_Create
+ """
+ profile_name = f"test-cert-create-{uuid.uuid4().hex[:6]}"
+
+ ca_cert = CertificateProfilesCaCertificatesInner(
+ name="Forward-Trust-CA",
+ default_ocsp_url="http://test.com",
+ )
+
+ username_field = CertificateProfilesUsernameField(
+ subject="common-name"
+ )
+
+ payload = CertificateProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ ca_certificates=[ca_cert],
+ domain="test",
+ use_crl=True,
+ use_ocsp=True,
+ block_unknown_cert=True,
+ block_timeout_cert=True,
+ block_unauthenticated_cert=True,
+ block_expired_cert=True,
+ username_field=username_field,
+ crl_receive_timeout="5",
+ ocsp_receive_timeout="5",
+ cert_status_timeout="5"
+ )
+
+ # Create with logging
+ created_obj = perform(
+ cert_profiles_api.create_certificate_profiles,
+ certificate_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == profile_name
+ assert created_obj.folder in ["Shared", "Prisma Access"]
+ assert len(created_obj.ca_certificates) == 1
+ assert created_obj.ca_certificates[0].name == "Forward-Trust-CA"
+ assert created_obj.ca_certificates[0].default_ocsp_url == "http://test.com"
+ assert created_obj.domain == "test"
+ assert created_obj.use_crl == True
+ assert created_obj.use_ocsp == True
+ assert created_obj.block_unknown_cert == True
+ assert created_obj.block_timeout_cert == True
+ assert created_obj.block_unauthenticated_cert == True
+ assert created_obj.block_expired_cert == True
+ assert created_obj.username_field.subject == "common-name"
+ assert created_obj.crl_receive_timeout == "5"
+ assert created_obj.ocsp_receive_timeout == "5"
+ assert created_obj.cert_status_timeout == "5"
+
+ # Cleanup with logging
+ perform(
+ cert_profiles_api.delete_certificate_profiles_by_id,
+ id=created_obj.id
+ )
+
+
+def test_get_cert_profile_by_id(cert_profiles_api, clean_cert_profile):
+ """
+ Test retrieving a Certificate Profile by ID with logging.
+ Mirrors Test_identityservices_CertificateProfilesAPIService_GetByID
+ """
+ fetched_obj = perform(
+ cert_profiles_api.get_certificate_profiles_by_id,
+ id=clean_cert_profile.id
+ )
+
+ assert fetched_obj.id == clean_cert_profile.id
+ assert fetched_obj.name == clean_cert_profile.name
+
+
+def test_update_cert_profile(cert_profiles_api, clean_cert_profile):
+ """
+ Test updating a Certificate Profile with logging.
+ Mirrors Test_identityservices_CertificateProfilesAPIService_Update
+ """
+ update_payload = clean_cert_profile
+ update_payload.domain = "updated-domain"
+ update_payload.crl_receive_timeout = "10"
+
+ updated_obj = perform(
+ cert_profiles_api.update_certificate_profiles_by_id,
+ id=clean_cert_profile.id,
+ certificate_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_cert_profile.id
+ assert updated_obj.domain == "updated-domain"
+ assert updated_obj.crl_receive_timeout == "10"
+
+
+def test_list_cert_profiles(cert_profiles_api, clean_cert_profile):
+ """
+ Test listing Certificate Profiles with logging.
+ Mirrors Test_identityservices_CertificateProfilesAPIService_List
+ """
+ response = perform(
+ cert_profiles_api.list_certificate_profiles,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ # Verify the fixture object is in the list
+ found = False
+ for item in response.data:
+ if item.id == clean_cert_profile.id:
+ found = True
+ break
+ assert found is True, f"Created profile {clean_cert_profile.id} not found in list response"
+
+
+
+
+def test_fetch_certificate_profiles(cert_profiles_api, clean_cert_profile):
+ """
+ Test fetching a single certificate_profiles by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = cert_profiles_api.fetch_certificate_profiles(
+ name=clean_cert_profile.name,
+ folder=clean_cert_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found certificate_profiles '{clean_cert_profile.name}'"
+ assert fetched_obj.id == clean_cert_profile.id
+ assert fetched_obj.name == clean_cert_profile.name
+ assert fetched_obj.folder == clean_cert_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_certificate_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent certificate_profiles (should return None)
+ not_found = cert_profiles_api.fetch_certificate_profiles(
+ name="non-existent-certificate_profiles-xyz-12345",
+ folder=clean_cert_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent certificate_profiles"
+ logger.info(f"\n[SUCCESS] fetch_certificate_profiles correctly returned None for non-existent certificate_profiles")
+
+
+def test_delete_cert_profile_by_id(cert_profiles_api):
+ """
+ Test deletion specifically with logging.
+ Mirrors Test_identityservices_CertificateProfilesAPIService_DeleteByID
+ """
+ # Setup
+ profile_name = f"test-cert-del-{uuid.uuid4().hex[:6]}"
+
+ ca_cert = CertificateProfilesCaCertificatesInner(
+ name="Forward-Trust-CA",
+ default_ocsp_url="http://test.com",
+ )
+
+ payload = CertificateProfiles(
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ ca_certificates=[ca_cert]
+ )
+
+ created_obj = perform(
+ cert_profiles_api.create_certificate_profiles,
+ certificate_profiles=payload
+ )
+
+ # Perform Delete with logging
+ perform(
+ cert_profiles_api.delete_certificate_profiles_by_id,
+ id=created_obj.id
+ )
+
+ # Verify Deletion
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ cert_profiles_api.get_certificate_profiles_by_id(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_certificates_test.py b/scm/identity_services/tests/api_certificates_test.py
new file mode 100644
index 00000000..9d0f9783
--- /dev/null
+++ b/scm/identity_services/tests/api_certificates_test.py
@@ -0,0 +1,32 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def certificates_api(client):
+ return client.identity_services.CertificatesApi(client.identity_services.api_client)
+
+
+def test_fetch_certificates(certificates_api):
+ """Test fetching a non-existent Certificate returns None."""
+ result = certificates_api.fetch_certificates(
+ name="non-existent-cert-xyz-12345",
+ folder=TARGET_FOLDER,
+ )
+ assert result is None, "Should return None for non-existent certificate"
+ logger.info("fetch_certificates correctly returned None for non-existent object")
diff --git a/scm/identity_services/tests/api_kerberos_server_profiles_test.py b/scm/identity_services/tests/api_kerberos_server_profiles_test.py
new file mode 100644
index 00000000..22669645
--- /dev/null
+++ b/scm/identity_services/tests/api_kerberos_server_profiles_test.py
@@ -0,0 +1,266 @@
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.identity_services.models.kerberos_server_profiles import KerberosServerProfiles
+from scm.identity_services.models.kerberos_server_profiles_server_inner import KerberosServerProfilesServerInner
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def kerberos_profiles_api(client):
+ """
+ Fixture to return the Kerberos Server Profiles API instance.
+ """
+ return client.identity_services.KerberosServerProfilesApi(client.identity_services.api_client)
+
+
+@pytest.fixture
+def clean_kerberos_profile(kerberos_profiles_api):
+ """
+ Fixture to create a temporary Kerberos Server Profile for testing and automatically delete it after.
+ """
+ object_name = f"test-kerb-{uuid.uuid4().hex[:6]}"
+
+ server = KerberosServerProfilesServerInner(
+ name="kerb-server-fixture",
+ host="10.0.1.50",
+ port=88
+ )
+
+ payload = KerberosServerProfiles(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ server=[server]
+ )
+
+ logger.info(f"\n[SETUP] Creating Kerberos Server Profile: {object_name}")
+ created_obj = perform(
+ kerberos_profiles_api.create_kerberos_server_profiles_with_http_info,
+ response_type=KerberosServerProfiles,
+ kerberos_server_profiles=payload
+ )
+
+ assert created_obj is not None, "API returned None for creation!"
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting Kerberos Server Profile ID: {created_obj.id}")
+ try:
+ perform(
+ kerberos_profiles_api.delete_kerberos_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_kerberos_profile(kerberos_profiles_api):
+ """
+ Test manual creation and deletion of a Kerberos Server Profile with logging.
+ Mirrors Test_identity_services_KerberosServerProfilesAPIService_Create
+ """
+ object_name = f"test-kerb-create-{uuid.uuid4().hex[:6]}"
+
+ servers = [
+ KerberosServerProfilesServerInner(
+ name="kerb-server-1",
+ host="10.0.1.50",
+ port=88
+ ),
+ KerberosServerProfilesServerInner(
+ name="kerb-server-2",
+ host="kerberos.example.com",
+ port=88
+ ),
+ ]
+
+ payload = KerberosServerProfiles(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ server=servers
+ )
+
+ created_obj = perform(
+ kerberos_profiles_api.create_kerberos_server_profiles_with_http_info,
+ response_type=KerberosServerProfiles,
+ kerberos_server_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == object_name
+ assert created_obj.folder == TARGET_FOLDER
+ assert len(created_obj.server) == 2
+
+ # Cleanup
+ perform(
+ kerberos_profiles_api.delete_kerberos_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_kerberos_profile_by_id(kerberos_profiles_api, clean_kerberos_profile):
+ """
+ Test retrieving a Kerberos Server Profile by ID with logging.
+ Mirrors Test_identity_services_KerberosServerProfilesAPIService_GetByID
+ """
+ fetched_obj = perform(
+ kerberos_profiles_api.get_kerberos_server_profiles_by_id_with_http_info,
+ id=clean_kerberos_profile.id
+ )
+
+ assert fetched_obj.id == clean_kerberos_profile.id
+ assert fetched_obj.name == clean_kerberos_profile.name
+
+
+def test_update_kerberos_profile(kerberos_profiles_api, clean_kerberos_profile):
+ """
+ Test updating a Kerberos Server Profile with logging.
+ Mirrors Test_identity_services_KerberosServerProfilesAPIService_Update
+ """
+ updated_servers = [
+ KerberosServerProfilesServerInner(
+ name="updated-test-svr-1",
+ host="2.2.2.2",
+ port=8888
+ ),
+ KerberosServerProfilesServerInner(
+ name="updated-test-svr-2",
+ host="192.10.20.115",
+ port=10
+ ),
+ ]
+
+ update_payload = KerberosServerProfiles(
+ id="",
+ name=clean_kerberos_profile.name,
+ server=updated_servers
+ )
+
+ updated_obj = perform(
+ kerberos_profiles_api.update_kerberos_server_profiles_by_id_with_http_info,
+ id=clean_kerberos_profile.id,
+ kerberos_server_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_kerberos_profile.id
+ assert updated_obj.server[0].name == "updated-test-svr-1"
+ assert updated_obj.server[1].name == "updated-test-svr-2"
+ assert updated_obj.server[0].port == 8888
+
+
+def test_list_kerberos_profiles(kerberos_profiles_api, clean_kerberos_profile):
+ """
+ Test listing Kerberos Server Profiles with logging.
+ Mirrors Test_identity_services_KerberosServerProfilesAPIService_List
+ """
+ response = perform(
+ kerberos_profiles_api.list_kerberos_server_profiles_with_http_info,
+ folder=TARGET_FOLDER,
+ limit=200
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_kerberos_profile.name:
+ found = True
+ break
+ assert found is True, f"Created profile {clean_kerberos_profile.name} not found in list response"
+
+
+def test_fetch_kerberos_server_profiles(kerberos_profiles_api, clean_kerberos_profile):
+ """
+ Test fetching a single kerberos_server_profiles by name using the fetch convenience method.
+ """
+ # Fetch by exact name
+ fetched_obj = kerberos_profiles_api.fetch_kerberos_server_profiles(
+ name=clean_kerberos_profile.name,
+ folder=clean_kerberos_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found kerberos_server_profiles '{clean_kerberos_profile.name}'"
+ assert fetched_obj.id == clean_kerberos_profile.id
+ assert fetched_obj.name == clean_kerberos_profile.name
+ assert fetched_obj.folder == clean_kerberos_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_kerberos_server_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent kerberos_server_profiles (should return None)
+ not_found = kerberos_profiles_api.fetch_kerberos_server_profiles(
+ name="non-existent-kerberos-server-profiles-xyz-12345",
+ folder=clean_kerberos_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent kerberos_server_profiles"
+ logger.info(f"\n[SUCCESS] fetch_kerberos_server_profiles correctly returned None for non-existent kerberos_server_profiles")
+
+
+def test_delete_kerberos_profile_by_id(kerberos_profiles_api):
+ """
+ Test deletion specifically with logging.
+ Mirrors Test_identity_services_KerberosServerProfilesAPIService_DeleteByID
+ """
+ object_name = f"test-kerb-del-{uuid.uuid4().hex[:6]}"
+
+ server = KerberosServerProfilesServerInner(
+ name="del-svr",
+ host="4.4.4.4"
+ )
+
+ payload = KerberosServerProfiles(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ server=[server]
+ )
+
+ created_obj = perform(
+ kerberos_profiles_api.create_kerberos_server_profiles_with_http_info,
+ response_type=KerberosServerProfiles,
+ kerberos_server_profiles=payload
+ )
+
+ # Perform Delete
+ perform(
+ kerberos_profiles_api.delete_kerberos_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ # Verify Deletion
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ kerberos_profiles_api.get_kerberos_server_profiles_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ logger.info(f"Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_ldap_server_profiles_test.py b/scm/identity_services/tests/api_ldap_server_profiles_test.py
new file mode 100644
index 00000000..90a772fa
--- /dev/null
+++ b/scm/identity_services/tests/api_ldap_server_profiles_test.py
@@ -0,0 +1,32 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def ldap_server_profiles_api(client):
+ return client.identity_services.LDAPServerProfilesApi(client.identity_services.api_client)
+
+
+def test_fetch_ldap_server_profiles(ldap_server_profiles_api):
+ """Test fetching a non-existent LDAP Server Profile returns None."""
+ result = ldap_server_profiles_api.fetch_ldap_server_profiles(
+ name="non-existent-ldap-xyz-12345",
+ folder=TARGET_FOLDER,
+ )
+ assert result is None, "Should return None for non-existent ldap server profile"
+ logger.info("fetch_ldap_server_profiles correctly returned None for non-existent object")
diff --git a/scm/identity_services/tests/api_local_user_groups_test.py b/scm/identity_services/tests/api_local_user_groups_test.py
new file mode 100644
index 00000000..21a90786
--- /dev/null
+++ b/scm/identity_services/tests/api_local_user_groups_test.py
@@ -0,0 +1,222 @@
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.identity_services.models.local_user_groups import LocalUserGroups
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "Prisma Access"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def local_user_groups_api(client):
+ """
+ Fixture to return the Local User Groups API instance.
+ """
+ return client.identity_services.LocalUserGroupsApi(client.identity_services.api_client)
+
+
+@pytest.fixture
+def clean_local_user_group(local_user_groups_api):
+ """
+ Fixture to create a temporary Local User Group for testing and automatically delete it after.
+ """
+ object_name = f"test-user-grp-{uuid.uuid4().hex[:6]}"
+
+ payload = LocalUserGroups(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER
+ )
+
+ logger.info(f"\n[SETUP] Creating Local User Group: {object_name}")
+ created_obj = perform(
+ local_user_groups_api.create_local_user_groups_with_http_info,
+ response_type=LocalUserGroups,
+ local_user_groups=payload
+ )
+
+ assert created_obj is not None, "API returned None for creation!"
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting Local User Group ID: {created_obj.id}")
+ try:
+ perform(
+ local_user_groups_api.delete_local_user_groups_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_local_user_group(local_user_groups_api):
+ """
+ Test manual creation and deletion of a Local User Group with logging.
+ Mirrors Test_identity_services_LocalUserGroupsAPIService_Create
+ """
+ object_name = f"test-user-grp-{uuid.uuid4().hex[:6]}"
+
+ payload = LocalUserGroups(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER
+ )
+
+ created_obj = perform(
+ local_user_groups_api.create_local_user_groups_with_http_info,
+ response_type=LocalUserGroups,
+ local_user_groups=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == object_name
+
+ # Cleanup
+ perform(
+ local_user_groups_api.delete_local_user_groups_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_local_user_group_by_id(local_user_groups_api, clean_local_user_group):
+ """
+ Test retrieving a Local User Group by ID with logging.
+ Mirrors Test_identity_services_LocalUserGroupsAPIService_GetByID
+ """
+ fetched_obj = perform(
+ local_user_groups_api.get_local_user_groups_by_id_with_http_info,
+ id=clean_local_user_group.id
+ )
+
+ assert fetched_obj.id == clean_local_user_group.id
+ assert fetched_obj.name == clean_local_user_group.name
+
+
+def test_update_local_user_group(local_user_groups_api, clean_local_user_group):
+ """
+ Test updating a Local User Group with logging.
+ Mirrors Test_identity_services_LocalUserGroupsAPIService_Update
+ Note: This is a no-op update to verify the API endpoint works (same as Go test).
+ """
+ update_payload = LocalUserGroups(
+ id="",
+ name=clean_local_user_group.name,
+ folder=TARGET_FOLDER
+ )
+
+ updated_obj = perform(
+ local_user_groups_api.update_local_user_groups_by_id_with_http_info,
+ id=clean_local_user_group.id,
+ local_user_groups=update_payload
+ )
+
+ assert updated_obj.id == clean_local_user_group.id
+ assert updated_obj.name == clean_local_user_group.name
+
+
+def test_list_local_user_groups(local_user_groups_api, clean_local_user_group):
+ """
+ Test listing Local User Groups with logging.
+ Mirrors Test_identity_services_LocalUserGroupsAPIService_List
+ """
+ response = perform(
+ local_user_groups_api.list_local_user_groups_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.id == clean_local_user_group.id:
+ found = True
+ assert item.name == clean_local_user_group.name
+ break
+ assert found is True, f"Created group {clean_local_user_group.id} not found in list response"
+
+
+def test_fetch_local_user_groups(local_user_groups_api, clean_local_user_group):
+ """
+ Test fetching a single local_user_groups by name using the fetch convenience method.
+ """
+ # Fetch by exact name
+ fetched_obj = local_user_groups_api.fetch_local_user_groups(
+ name=clean_local_user_group.name,
+ folder=clean_local_user_group.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found local_user_groups '{clean_local_user_group.name}'"
+ assert fetched_obj.id == clean_local_user_group.id
+ assert fetched_obj.name == clean_local_user_group.name
+ assert fetched_obj.folder == clean_local_user_group.folder
+ logger.info(f"\n[SUCCESS] fetch_local_user_groups found object: {fetched_obj.name}")
+
+ # Test fetching non-existent local_user_groups (should return None)
+ not_found = local_user_groups_api.fetch_local_user_groups(
+ name="non-existent-user-group-xyz-12345",
+ folder=clean_local_user_group.folder
+ )
+ assert not_found is None, "Should return None for non-existent local_user_groups"
+ logger.info(f"\n[SUCCESS] fetch_local_user_groups correctly returned None for non-existent local_user_groups")
+
+
+def test_delete_local_user_group_by_id(local_user_groups_api):
+ """
+ Test deletion specifically with logging.
+ Mirrors Test_identity_services_LocalUserGroupsAPIService_DeleteByID
+ """
+ object_name = f"test-user-grp-{uuid.uuid4().hex[:6]}"
+
+ payload = LocalUserGroups(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER
+ )
+
+ created_obj = perform(
+ local_user_groups_api.create_local_user_groups_with_http_info,
+ response_type=LocalUserGroups,
+ local_user_groups=payload
+ )
+
+ # Perform Delete
+ perform(
+ local_user_groups_api.delete_local_user_groups_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ # Verify Deletion
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ local_user_groups_api.get_local_user_groups_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Local User Group should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ logger.info(f"Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_local_users_test.py b/scm/identity_services/tests/api_local_users_test.py
new file mode 100644
index 00000000..778f4041
--- /dev/null
+++ b/scm/identity_services/tests/api_local_users_test.py
@@ -0,0 +1,32 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "Prisma Access"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def local_users_api(client):
+ return client.identity_services.LocalUsersApi(client.identity_services.api_client)
+
+
+def test_fetch_local_users(local_users_api):
+ """Test fetching a non-existent Local User returns None."""
+ result = local_users_api.fetch_local_users(
+ name="non-existent-user-xyz-12345",
+ folder=TARGET_FOLDER,
+ )
+ assert result is None, "Should return None for non-existent local user"
+ logger.info("fetch_local_users correctly returned None for non-existent object")
diff --git a/scm/identity_services/tests/api_mfa_servers_test.py b/scm/identity_services/tests/api_mfa_servers_test.py
new file mode 100644
index 00000000..552b7aea
--- /dev/null
+++ b/scm/identity_services/tests/api_mfa_servers_test.py
@@ -0,0 +1,40 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+TARGET_FOLDER = "All"
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def mfa_servers_api(client):
+ return client.identity_services.MFAServersApi(client.identity_services.api_client)
+
+
+def test_list_mfa_servers(mfa_servers_api):
+ """Test listing MFA Servers."""
+ response = mfa_servers_api.list_mfa_servers(folder=TARGET_FOLDER, position="pre", limit=200, offset=0)
+ assert response is not None
+ logger.info(f"Listed MFA Servers successfully")
+
+
+def test_fetch_mfa_servers(mfa_servers_api):
+ """Test fetching a non-existent MFA Server returns None."""
+ result = mfa_servers_api.fetch_mfa_servers(
+ name="non-existent-mfa-server-xyz-12345",
+ folder=TARGET_FOLDER,
+ position="pre",
+ )
+ assert result is None, "Should return None for non-existent mfa server"
+ logger.info("fetch_mfa_servers correctly returned None for non-existent object")
diff --git a/scm/identity_services/tests/api_ocsp_responders_test.py b/scm/identity_services/tests/api_ocsp_responders_test.py
new file mode 100644
index 00000000..883334d8
--- /dev/null
+++ b/scm/identity_services/tests/api_ocsp_responders_test.py
@@ -0,0 +1,235 @@
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.identity_services.models.ocsp_responders import OcspResponders
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "Prisma Access"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def ocsp_responders_api(client):
+ """
+ Fixture to return the OCSP Responders API instance.
+ """
+ return client.identity_services.OCSPRespondersApi(client.identity_services.api_client)
+
+
+@pytest.fixture
+def clean_ocsp_responder(ocsp_responders_api):
+ """
+ Fixture to create a temporary OCSP Responder for testing and automatically delete it after.
+ Note: Create returns None (no model), so we use Fetch to retrieve the created object.
+ """
+ object_name = f"test-ocsp-{uuid.uuid4().hex[:6]}"
+
+ payload = OcspResponders(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ host_name="ocsp-fixture.example.com"
+ )
+
+ logger.info(f"\n[SETUP] Creating OCSP Responder: {object_name}")
+ # Create returns None (no model body in 201 response)
+ ocsp_responders_api.create_ocsp_responders(ocsp_responders=payload)
+
+ # Use Fetch to retrieve the created object and get the ID
+ created_obj = ocsp_responders_api.fetch_ocsp_responders(
+ name=object_name,
+ folder=TARGET_FOLDER
+ )
+ assert created_obj is not None, "Failed to fetch OCSP Responder after creation"
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting OCSP Responder ID: {created_obj.id}")
+ try:
+ perform(
+ ocsp_responders_api.delete_ocsp_responders_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_ocsp_responder(ocsp_responders_api):
+ """
+ Test manual creation and deletion of an OCSP Responder with logging.
+ Mirrors Test_identity_services_OCSPRespondersAPIService_Create
+ Note: Create returns no model, so we use Fetch to verify.
+ """
+ object_name = f"test-ocsp-create-{uuid.uuid4().hex[:6]}"
+
+ payload = OcspResponders(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ host_name="ocsp.example.com"
+ )
+
+ # Create (returns None)
+ ocsp_responders_api.create_ocsp_responders(ocsp_responders=payload)
+
+ # Use Fetch to verify the object was created and get the ID
+ fetched_obj = ocsp_responders_api.fetch_ocsp_responders(
+ name=object_name,
+ folder=TARGET_FOLDER
+ )
+
+ assert fetched_obj is not None, "Failed to fetch OCSP Responder after creation"
+ assert fetched_obj.name == object_name
+ assert fetched_obj.host_name == "ocsp.example.com"
+
+ # Cleanup
+ perform(
+ ocsp_responders_api.delete_ocsp_responders_by_id_with_http_info,
+ id=fetched_obj.id
+ )
+
+
+def test_get_ocsp_responder_by_id(ocsp_responders_api, clean_ocsp_responder):
+ """
+ Test retrieving an OCSP Responder by ID with logging.
+ Mirrors Test_identity_services_OCSPRespondersAPIService_GetByID
+ """
+ fetched_obj = perform(
+ ocsp_responders_api.get_ocsp_responders_by_id_with_http_info,
+ id=clean_ocsp_responder.id
+ )
+
+ assert fetched_obj.id == clean_ocsp_responder.id
+ assert fetched_obj.name == clean_ocsp_responder.name
+
+
+def test_update_ocsp_responder(ocsp_responders_api, clean_ocsp_responder):
+ """
+ Test updating an OCSP Responder with logging.
+ Mirrors Test_identity_services_OCSPRespondersAPIService_Update
+ """
+ update_payload = OcspResponders(
+ id="",
+ name=clean_ocsp_responder.name,
+ host_name="ocsp-updated.example.com"
+ )
+
+ updated_obj = perform(
+ ocsp_responders_api.update_ocsp_responders_by_id_with_http_info,
+ id=clean_ocsp_responder.id,
+ ocsp_responders=update_payload
+ )
+
+ assert updated_obj.id == clean_ocsp_responder.id
+ assert updated_obj.host_name == "ocsp-updated.example.com"
+
+
+def test_list_ocsp_responders(ocsp_responders_api, clean_ocsp_responder):
+ """
+ Test listing OCSP Responders with logging.
+ Mirrors Test_identity_services_OCSPRespondersAPIService_List
+ """
+ response = perform(
+ ocsp_responders_api.list_ocsp_responders_with_http_info,
+ folder=TARGET_FOLDER,
+ limit=200
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_ocsp_responder.name:
+ found = True
+ break
+ assert found is True, f"Created OCSP Responder {clean_ocsp_responder.name} not found in list response"
+
+
+def test_fetch_ocsp_responders(ocsp_responders_api, clean_ocsp_responder):
+ """
+ Test fetching a single ocsp_responders by name using the fetch convenience method.
+ """
+ # Fetch by exact name
+ fetched_obj = ocsp_responders_api.fetch_ocsp_responders(
+ name=clean_ocsp_responder.name,
+ folder=clean_ocsp_responder.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found ocsp_responders '{clean_ocsp_responder.name}'"
+ assert fetched_obj.id == clean_ocsp_responder.id
+ assert fetched_obj.name == clean_ocsp_responder.name
+ assert fetched_obj.folder == clean_ocsp_responder.folder
+ logger.info(f"\n[SUCCESS] fetch_ocsp_responders found object: {fetched_obj.name}")
+
+ # Test fetching non-existent ocsp_responders (should return None)
+ not_found = ocsp_responders_api.fetch_ocsp_responders(
+ name="non-existent-ocsp-responders-xyz-12345",
+ folder=clean_ocsp_responder.folder
+ )
+ assert not_found is None, "Should return None for non-existent ocsp_responders"
+ logger.info(f"\n[SUCCESS] fetch_ocsp_responders correctly returned None for non-existent ocsp_responders")
+
+
+def test_delete_ocsp_responder_by_id(ocsp_responders_api):
+ """
+ Test deletion specifically with logging.
+ Mirrors Test_identity_services_OCSPRespondersAPIService_DeleteByID
+ """
+ object_name = f"test-ocsp-del-{uuid.uuid4().hex[:6]}"
+
+ payload = OcspResponders(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ host_name="ocsp-delete.example.com"
+ )
+
+ # Create (returns None)
+ ocsp_responders_api.create_ocsp_responders(ocsp_responders=payload)
+
+ # Use Fetch to get the ID
+ fetched_obj = ocsp_responders_api.fetch_ocsp_responders(
+ name=object_name,
+ folder=TARGET_FOLDER
+ )
+ assert fetched_obj is not None, "Failed to fetch OCSP Responder for delete test"
+
+ # Perform Delete
+ perform(
+ ocsp_responders_api.delete_ocsp_responders_by_id_with_http_info,
+ id=fetched_obj.id
+ )
+
+ # Verify Deletion
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ ocsp_responders_api.get_ocsp_responders_by_id_with_http_info(id=fetched_obj.id)
+ pytest.fail("OCSP Responder should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ logger.info(f"Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {fetched_obj.id}")
diff --git a/scm/identity_services/tests/api_radius_server_profiles_test.py b/scm/identity_services/tests/api_radius_server_profiles_test.py
new file mode 100644
index 00000000..fdd8c34e
--- /dev/null
+++ b/scm/identity_services/tests/api_radius_server_profiles_test.py
@@ -0,0 +1,250 @@
+
+
+import logging
+import uuid
+import json
+import pytest
+from scm import Scm
+from scm.identity_services.models.radius_server_profiles import RadiusServerProfiles
+from scm.identity_services.models.radius_server_profiles_protocol import RadiusServerProfilesProtocol
+from scm.identity_services.models.radius_server_profiles_server_inner import RadiusServerProfilesServerInner
+from scm.test_helpers import perform
+
+# Configure logging to see details during test execution (use pytest -s)
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def radius_profiles_api(client):
+ """
+ Fixture to return the RADIUS Server Profiles API instance.
+ """
+ return client.identity_services.RADIUSServerProfilesApi(client.identity_services.api_client)
+
+@pytest.fixture
+def clean_radius_profile(radius_profiles_api):
+ """
+ Fixture to create a temporary RADIUS Server Profile for testing and automatically delete it after.
+ """
+ # 1. SETUP
+ server_inner = RadiusServerProfilesServerInner(
+ name="radius-server-fixture",
+ ip_address="10.1.1.1",
+ secret="secret123",
+ port=1812
+ )
+ protocol = RadiusServerProfilesProtocol(pap={})
+ object_name = f"scm-radius-test-{uuid.uuid4().hex[:6]}"
+
+ payload = RadiusServerProfiles(
+ id="",
+ name=object_name,
+ protocol=protocol,
+ server=[server_inner],
+ retries=3,
+ timeout=10,
+ folder=TARGET_FOLDER
+ )
+
+ # Use _with_http_info to ensure we get the object back even on 201 Created
+ created_obj = perform(
+ radius_profiles_api.create_radius_server_profiles_with_http_info,
+ radius_server_profiles=payload
+ )
+
+ assert created_obj is not None, "API returned None for creation!"
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ # 2. TEARDOWN
+ logger.info(f"\n[TEARDOWN] Deleting RADIUS Profile ID: {created_obj.id}")
+ try:
+ perform(
+ radius_profiles_api.delete_radius_server_profiles_by_id,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_radius_profile(radius_profiles_api):
+ """
+ Test manual creation and deletion of a RADIUS Server Profile with logging.
+ """
+ server_inner = RadiusServerProfilesServerInner(
+ name="radius-server-manual",
+ ip_address="10.2.2.2",
+ secret="manualSecret",
+ port=1812
+ )
+ protocol = RadiusServerProfilesProtocol(pap={})
+ object_name = f"scm-radius-create-{uuid.uuid4().hex[:6]}"
+
+ payload = RadiusServerProfiles(
+ id="",
+ name=object_name,
+ protocol=protocol,
+ server=[server_inner],
+ retries=5,
+ timeout=15,
+ folder=TARGET_FOLDER
+ )
+
+ # Create with logging using _with_http_info
+ created_obj = perform(
+ radius_profiles_api.create_radius_server_profiles_with_http_info,
+ radius_server_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.name == object_name
+ assert created_obj.id is not None
+ assert created_obj.retries == 5
+
+ # Cleanup with logging
+ perform(
+ radius_profiles_api.delete_radius_server_profiles_by_id,
+ id=created_obj.id
+ )
+
+
+def test_get_radius_profile_by_id(radius_profiles_api, clean_radius_profile):
+ """
+ Test retrieving a RADIUS Server Profile by ID with logging.
+ """
+ fetched_obj = perform(
+ radius_profiles_api.get_radius_server_profiles_by_id,
+ id=clean_radius_profile.id
+ )
+
+ assert fetched_obj.id == clean_radius_profile.id
+ assert fetched_obj.name == clean_radius_profile.name
+ assert fetched_obj.timeout == clean_radius_profile.timeout
+
+
+def test_update_radius_profile(radius_profiles_api, clean_radius_profile):
+ """
+ Test updating a RADIUS Server Profile with logging.
+ """
+ update_payload = clean_radius_profile
+ update_payload.retries = 2
+ update_payload.timeout = 60
+ update_payload.folder = TARGET_FOLDER
+
+ updated_obj = perform(
+ radius_profiles_api.update_radius_server_profiles_by_id,
+ id=clean_radius_profile.id,
+ radius_server_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_radius_profile.id
+ assert updated_obj.retries == 2
+ assert updated_obj.timeout == 60
+
+
+def test_list_radius_profiles(radius_profiles_api, clean_radius_profile):
+ """
+ Test listing RADIUS Server Profiles with logging.
+ """
+ response = perform(
+ radius_profiles_api.list_radius_server_profiles,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+
+
+
+def test_fetch_radius_server_profiles(radius_profiles_api, clean_radius_profile):
+ """
+ Test fetching a single radius_server_profiles by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = radius_profiles_api.fetch_radius_server_profiles(
+ name=clean_radius_profile.name,
+ folder=clean_radius_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found radius_server_profiles '{clean_radius_profile.name}'"
+ assert fetched_obj.id == clean_radius_profile.id
+ assert fetched_obj.name == clean_radius_profile.name
+ assert fetched_obj.folder == clean_radius_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_radius_server_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent radius_server_profiles (should return None)
+ not_found = radius_profiles_api.fetch_radius_server_profiles(
+ name="non-existent-radius_server_profiles-xyz-12345",
+ folder=clean_radius_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent radius_server_profiles"
+ logger.info(f"\n[SUCCESS] fetch_radius_server_profiles correctly returned None for non-existent radius_server_profiles")
+
+
+def test_delete_radius_profile_by_id(radius_profiles_api):
+ """
+ Test deletion specifically with logging.
+ """
+ # Setup
+ server_inner = RadiusServerProfilesServerInner(
+ name="radius-server-del",
+ ip_address="10.3.3.3",
+ secret="delSecret",
+ port=1812
+ )
+ protocol = RadiusServerProfilesProtocol(pap={})
+ object_name = f"scm-radius-del-{uuid.uuid4().hex[:6]}"
+
+ payload = RadiusServerProfiles(
+ id="",
+ name=object_name,
+ protocol=protocol,
+ server=[server_inner],
+ folder=TARGET_FOLDER
+ )
+
+ # Use _with_http_info for setup as well
+ created_obj = perform(
+ radius_profiles_api.create_radius_server_profiles_with_http_info,
+ radius_server_profiles=payload
+ )
+
+ # Perform Delete with logging
+ perform(
+ radius_profiles_api.delete_radius_server_profiles_by_id,
+ id=created_obj.id
+ )
+
+ # Verify Deletion
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ radius_profiles_api.get_radius_server_profiles_by_id(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_saml_server_profiles_test.py b/scm/identity_services/tests/api_saml_server_profiles_test.py
new file mode 100644
index 00000000..8b3d6d2b
--- /dev/null
+++ b/scm/identity_services/tests/api_saml_server_profiles_test.py
@@ -0,0 +1,204 @@
+import logging
+import uuid
+import json
+import pytest
+from scm import Scm
+from scm.identity_services.models.saml_server_profiles import SamlServerProfiles
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def saml_profiles_api(client):
+ return client.identity_services.SAMLServerProfilesApi(client.identity_services.api_client)
+
+@pytest.fixture
+def clean_saml_profile(saml_profiles_api):
+ profile_name = f"test-saml-prof-{uuid.uuid4().hex[:6]}"
+
+ payload = SamlServerProfiles(
+ id="", # Workaround: id incorrectly marked as required in model
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ certificate="Global Authentication Cookie Cert",
+ entity_id="https://idp.example.com/entity",
+ sso_url="https://idp.example.com/sso",
+ sso_bindings="redirect"
+ )
+
+ logger.info(f"\n[SETUP] Creating SAML Server Profile: {profile_name}")
+ created_obj = perform(
+ saml_profiles_api.create_saml_server_profiles_with_http_info,
+ response_type=SamlServerProfiles,
+ saml_server_profiles=payload
+ )
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting SAML Server Profile ID: {created_obj.id}")
+ try:
+ perform(
+ saml_profiles_api.delete_saml_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed: {e}")
+
+
+def test_create_saml_profile(saml_profiles_api):
+ profile_name = f"test-saml-create-{uuid.uuid4().hex[:6]}"
+
+ payload = SamlServerProfiles(
+ id="", # Workaround: id incorrectly marked as required in model
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ certificate="Global Authentication Cookie Cert",
+ entity_id="https://idp.complex.com/entity",
+ sso_url="https://idp.complex.com/sso",
+ sso_bindings="post",
+ slo_url="https://idp.complex.com/slo",
+ slo_bindings="redirect",
+ max_clock_skew=180,
+ validate_idp_certificate=False,
+ want_auth_requests_signed=True
+ )
+
+ created_obj = perform(
+ saml_profiles_api.create_saml_server_profiles_with_http_info,
+ response_type=SamlServerProfiles,
+ saml_server_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == profile_name
+
+ perform(
+ saml_profiles_api.delete_saml_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_saml_profile_by_id(saml_profiles_api, clean_saml_profile):
+ fetched_obj = perform(
+ saml_profiles_api.get_saml_server_profiles_by_id_with_http_info,
+ id=clean_saml_profile.id
+ )
+
+ assert fetched_obj.id == clean_saml_profile.id
+ assert fetched_obj.name == clean_saml_profile.name
+
+
+def test_update_saml_profile(saml_profiles_api, clean_saml_profile):
+ update_payload = clean_saml_profile
+ update_payload.sso_url = "https://idp.updated.com/sso"
+ update_payload.max_clock_skew = 500
+
+ updated_obj = perform(
+ saml_profiles_api.update_saml_server_profiles_by_id_with_http_info,
+ id=clean_saml_profile.id,
+ saml_server_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_saml_profile.id
+ assert updated_obj.sso_url == "https://idp.updated.com/sso"
+ assert updated_obj.max_clock_skew == 500
+
+
+def test_list_saml_profiles(saml_profiles_api, clean_saml_profile):
+ response = perform(
+ saml_profiles_api.list_saml_server_profiles_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.id == clean_saml_profile.id:
+ found = True
+ break
+ assert found is True, f"Created profile {clean_saml_profile.id} not found in list response"
+
+
+
+
+def test_fetch_saml_server_profiles(saml_profiles_api, clean_saml_profile):
+ """
+ Test fetching a single saml_server_profiles by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = saml_profiles_api.fetch_saml_server_profiles(
+ name=clean_saml_profile.name,
+ folder=clean_saml_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found saml_server_profiles '{clean_saml_profile.name}'"
+ assert fetched_obj.id == clean_saml_profile.id
+ assert fetched_obj.name == clean_saml_profile.name
+ assert fetched_obj.folder == clean_saml_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_saml_server_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent saml_server_profiles (should return None)
+ not_found = saml_profiles_api.fetch_saml_server_profiles(
+ name="non-existent-saml_server_profiles-xyz-12345",
+ folder=clean_saml_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent saml_server_profiles"
+ logger.info(f"\n[SUCCESS] fetch_saml_server_profiles correctly returned None for non-existent saml_server_profiles")
+
+
+def test_delete_saml_profile_by_id(saml_profiles_api):
+ profile_name = f"test-saml-del-{uuid.uuid4().hex[:6]}"
+
+ payload = SamlServerProfiles(
+ id="", # Workaround: id incorrectly marked as required in model
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ certificate="Global Authentication Cookie Cert",
+ entity_id="https://idp.example.com/entity",
+ sso_url="https://idp.example.com/sso",
+ sso_bindings="redirect"
+ )
+
+ created_obj = perform(
+ saml_profiles_api.create_saml_server_profiles_with_http_info,
+ response_type=SamlServerProfiles,
+ saml_server_profiles=payload
+ )
+
+ perform(
+ saml_profiles_api.delete_saml_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ saml_profiles_api.get_saml_server_profiles_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_scep_profiles_test.py b/scm/identity_services/tests/api_scep_profiles_test.py
new file mode 100644
index 00000000..a6d9326c
--- /dev/null
+++ b/scm/identity_services/tests/api_scep_profiles_test.py
@@ -0,0 +1,267 @@
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.identity_services.models.scep_profiles import ScepProfiles
+from scm.identity_services.models.scep_profiles_algorithm import ScepProfilesAlgorithm
+from scm.identity_services.models.scep_profiles_algorithm_rsa import ScepProfilesAlgorithmRsa
+from scm.identity_services.models.scep_profiles_scep_challenge import ScepProfilesScepChallenge
+from scm.identity_services.models.scep_profiles_scep_challenge_dynamic import ScepProfilesScepChallengeDynamic
+from scm.identity_services.models.scep_profiles_certificate_attributes import ScepProfilesCertificateAttributes
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def scep_profiles_api(client):
+ return client.identity_services.SCEPProfilesApi(client.identity_services.api_client)
+
+
+@pytest.fixture
+def clean_scep_profile(scep_profiles_api):
+ """
+ Setup/Teardown for a simple SCEP profile.
+ """
+ profile_name = f"scm-scep-{uuid.uuid4().hex[:6]}"
+
+ algorithm = ScepProfilesAlgorithm(
+ rsa=ScepProfilesAlgorithmRsa(
+ rsa_nbits="2048"
+ )
+ )
+
+ challenge = ScepProfilesScepChallenge(
+ fixed="mypassword123"
+ )
+
+ payload = ScepProfiles(
+ id="",
+ folder=TARGET_FOLDER,
+ name=profile_name,
+ scep_url="https://scep.example.com/",
+ ca_identity_name="Default",
+ digest="sha256",
+ subject="CN=$USERNAME",
+ algorithm=algorithm,
+ scep_challenge=challenge
+ )
+
+ logger.info(f"\n[SETUP] Creating SCEP Profile: {profile_name}")
+ created_profile = perform(
+ scep_profiles_api.create_scep_profiles_with_http_info,
+ response_type=ScepProfiles,
+ scep_profiles=payload
+ )
+
+ yield created_profile
+
+ logger.info(f"\n[TEARDOWN] Deleting SCEP Profile: {created_profile.id}")
+ try:
+ perform(
+ scep_profiles_api.delete_scep_profiles_by_id_with_http_info,
+ id=created_profile.id
+ )
+ except Exception as e:
+ logger.error(f"Failed to cleanup SCEP profile: {e}")
+
+
+def test_create_scep_profile(scep_profiles_api):
+ """Test creation of a complex SCEP Profile."""
+ profile_name = f"scm-scep-create-{uuid.uuid4().hex[:6]}"
+
+ algorithm = ScepProfilesAlgorithm(
+ rsa=ScepProfilesAlgorithmRsa(
+ rsa_nbits="2048"
+ )
+ )
+
+ dynamic_settings = ScepProfilesScepChallengeDynamic(
+ username="scep-admin",
+ password="mypassword123",
+ otp_server_url="https://otp.example.com/api/v1/generate"
+ )
+
+ challenge = ScepProfilesScepChallenge(
+ dynamic=dynamic_settings
+ )
+
+ attributes = ScepProfilesCertificateAttributes(
+ dnsname="device.example.com"
+ )
+
+ payload = ScepProfiles(
+ id="",
+ folder=TARGET_FOLDER,
+ name=profile_name,
+ scep_url="https://scep.example.com/certsrv/mscep/mscep.dll",
+ ca_identity_name="Example-Name",
+ digest="sha256",
+ subject="CN=$USERNAME",
+ fingerprint="D14A028C2A3A2BC9476102BB288234C415A2B01F",
+ algorithm=algorithm,
+ scep_challenge=challenge,
+ scep_ca_cert="Forward-Trust-CA",
+ scep_client_cert="Forward-UnTrust-CA",
+ certificate_attributes=attributes,
+ use_as_digital_signature=True,
+ use_for_key_encipherment=True
+ )
+
+ created_obj = perform(
+ scep_profiles_api.create_scep_profiles_with_http_info,
+ response_type=ScepProfiles,
+ scep_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == profile_name
+ assert created_obj.digest == "sha256"
+
+ perform(
+ scep_profiles_api.delete_scep_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_scep_profile_by_id(scep_profiles_api, clean_scep_profile):
+ """Test retrieving a SCEP Profile by ID."""
+ fetched_obj = perform(
+ scep_profiles_api.get_scep_profiles_by_id_with_http_info,
+ id=clean_scep_profile.id
+ )
+
+ assert fetched_obj.id == clean_scep_profile.id
+ assert fetched_obj.name == clean_scep_profile.name
+ assert fetched_obj.digest == "sha256"
+
+
+def test_update_scep_profile(scep_profiles_api, clean_scep_profile):
+ """Test updating a SCEP Profile."""
+ update_payload = clean_scep_profile
+ update_payload.digest = "sha512"
+ update_payload.ca_identity_name = "Updated-CA"
+
+ updated_obj = perform(
+ scep_profiles_api.update_scep_profiles_by_id_with_http_info,
+ id=clean_scep_profile.id,
+ scep_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_scep_profile.id
+ assert updated_obj.digest == "sha512"
+ assert updated_obj.ca_identity_name == "Updated-CA"
+
+
+def test_list_scep_profiles(scep_profiles_api, clean_scep_profile):
+ """Test listing SCEP Profiles."""
+ response = perform(
+ scep_profiles_api.list_scep_profiles_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_scep_profile.name:
+ found = True
+ break
+ assert found is True, f"Created profile {clean_scep_profile.name} not found in list response"
+
+
+
+
+def test_fetch_scep_profiles(scep_profiles_api, clean_scep_profile):
+ """
+ Test fetching a single scep_profiles by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = scep_profiles_api.fetch_scep_profiles(
+ name=clean_scep_profile.name,
+ folder=clean_scep_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found scep_profiles '{clean_scep_profile.name}'"
+ assert fetched_obj.id == clean_scep_profile.id
+ assert fetched_obj.name == clean_scep_profile.name
+ assert fetched_obj.folder == clean_scep_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_scep_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent scep_profiles (should return None)
+ not_found = scep_profiles_api.fetch_scep_profiles(
+ name="non-existent-scep_profiles-xyz-12345",
+ folder=clean_scep_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent scep_profiles"
+ logger.info(f"\n[SUCCESS] fetch_scep_profiles correctly returned None for non-existent scep_profiles")
+
+
+def test_delete_scep_profile_by_id(scep_profiles_api):
+ """Test deleting a SCEP Profile."""
+ profile_name = f"scm-scep-delete-{uuid.uuid4().hex[:6]}"
+
+ algorithm = ScepProfilesAlgorithm(
+ rsa=ScepProfilesAlgorithmRsa(
+ rsa_nbits="2048"
+ )
+ )
+
+ challenge = ScepProfilesScepChallenge(
+ fixed="mypassword123"
+ )
+
+ payload = ScepProfiles(
+ id="",
+ folder=TARGET_FOLDER,
+ name=profile_name,
+ scep_url="https://scep.example.com/",
+ ca_identity_name="Default",
+ digest="sha256",
+ subject="CN=$USERNAME",
+ algorithm=algorithm,
+ scep_challenge=challenge
+ )
+
+ created_obj = perform(
+ scep_profiles_api.create_scep_profiles_with_http_info,
+ response_type=ScepProfiles,
+ scep_profiles=payload
+ )
+
+ perform(
+ scep_profiles_api.delete_scep_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ scep_profiles_api.get_scep_profiles_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_tacacs_server_profiles_test.py b/scm/identity_services/tests/api_tacacs_server_profiles_test.py
new file mode 100644
index 00000000..12669204
--- /dev/null
+++ b/scm/identity_services/tests/api_tacacs_server_profiles_test.py
@@ -0,0 +1,267 @@
+import logging
+import uuid
+import pytest
+from scm import Scm
+from scm.identity_services.models.tacacs_server_profiles import TacacsServerProfiles
+from scm.identity_services.models.tacacs_server_profiles_server_inner import TacacsServerProfilesServerInner
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ """
+ Fixture to initialize the SCM client once for the module.
+ """
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def tacacs_profiles_api(client):
+ """
+ Fixture to return the TACACS Server Profiles API instance.
+ """
+ return client.identity_services.TACACSServerProfilesApi(client.identity_services.api_client)
+
+
+@pytest.fixture
+def clean_tacacs_profile(tacacs_profiles_api):
+ """
+ Fixture to create a temporary TACACS Server Profile for testing and automatically delete it after.
+ """
+ object_name = f"test-tacacs-{uuid.uuid4().hex[:6]}"
+
+ server = TacacsServerProfilesServerInner(
+ name="tacacs-server-fixture",
+ address="200.5.5.100",
+ port=20,
+ secret="a"
+ )
+
+ payload = TacacsServerProfiles(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ protocol="CHAP",
+ server=[server],
+ timeout=15,
+ use_single_connection=True
+ )
+
+ logger.info(f"\n[SETUP] Creating TACACS Server Profile: {object_name}")
+ created_obj = perform(
+ tacacs_profiles_api.create_tacacs_server_profiles_with_http_info,
+ response_type=TacacsServerProfiles,
+ tacacs_server_profiles=payload
+ )
+
+ assert created_obj is not None, "API returned None for creation!"
+ assert created_obj.id is not None
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting TACACS Server Profile ID: {created_obj.id}")
+ try:
+ perform(
+ tacacs_profiles_api.delete_tacacs_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed (might have been deleted in test): {e}")
+
+
+def test_create_tacacs_profile(tacacs_profiles_api):
+ """
+ Test manual creation and deletion of a TACACS Server Profile with logging.
+ Mirrors Test_identity_services_TACACSServerProfilesAPIService_Create
+ """
+ object_name = f"test-tacacs-create-{uuid.uuid4().hex[:6]}"
+
+ servers = [
+ TacacsServerProfilesServerInner(
+ name="tacacs-server-1",
+ address="200.5.5.100",
+ port=20,
+ secret="a"
+ ),
+ TacacsServerProfilesServerInner(
+ name="tacacs-server-2",
+ address="100.2.120.50",
+ port=1255,
+ secret="secret"
+ ),
+ TacacsServerProfilesServerInner(
+ name="tacacs-server-3",
+ address="address_3",
+ port=40000,
+ secret="68#67p!Z7mR8*ql1XwN8@b04yV0f83sJ6hA9%uC2775&dP8xhoK4*jQ7tW0zS3rK"
+ ),
+ ]
+
+ payload = TacacsServerProfiles(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ protocol="CHAP",
+ server=servers,
+ timeout=15,
+ use_single_connection=True
+ )
+
+ created_obj = perform(
+ tacacs_profiles_api.create_tacacs_server_profiles_with_http_info,
+ response_type=TacacsServerProfiles,
+ tacacs_server_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == object_name
+ assert created_obj.folder == TARGET_FOLDER
+ assert created_obj.protocol == "CHAP"
+ assert len(created_obj.server) == 3
+
+ # Cleanup
+ perform(
+ tacacs_profiles_api.delete_tacacs_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_tacacs_profile_by_id(tacacs_profiles_api, clean_tacacs_profile):
+ """
+ Test retrieving a TACACS Server Profile by ID with logging.
+ Mirrors Test_identity_services_TACACSServerProfilesAPIService_GetByID
+ """
+ fetched_obj = perform(
+ tacacs_profiles_api.get_tacacs_server_profiles_by_id_with_http_info,
+ id=clean_tacacs_profile.id
+ )
+
+ assert fetched_obj.id == clean_tacacs_profile.id
+ assert fetched_obj.name == clean_tacacs_profile.name
+
+
+def test_update_tacacs_profile(tacacs_profiles_api, clean_tacacs_profile):
+ """
+ Test updating a TACACS Server Profile with logging.
+ Mirrors Test_identity_services_TACACSServerProfilesAPIService_Update
+ """
+ update_payload = clean_tacacs_profile
+ update_payload.protocol = "PAP"
+ update_payload.timeout = 20
+
+ updated_obj = perform(
+ tacacs_profiles_api.update_tacacs_server_profiles_by_id_with_http_info,
+ id=clean_tacacs_profile.id,
+ tacacs_server_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_tacacs_profile.id
+ assert updated_obj.timeout == 20
+
+
+def test_list_tacacs_profiles(tacacs_profiles_api, clean_tacacs_profile):
+ """
+ Test listing TACACS Server Profiles with logging.
+ Mirrors Test_identity_services_TACACSServerProfilesAPIService_List
+ """
+ response = perform(
+ tacacs_profiles_api.list_tacacs_server_profiles_with_http_info,
+ folder=TARGET_FOLDER,
+ limit=200
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.name == clean_tacacs_profile.name:
+ found = True
+ break
+ assert found is True, f"Created profile {clean_tacacs_profile.name} not found in list response"
+
+
+def test_fetch_tacacs_server_profiles(tacacs_profiles_api, clean_tacacs_profile):
+ """
+ Test fetching a single tacacs_server_profiles by name using the fetch convenience method.
+ """
+ # Fetch by exact name
+ fetched_obj = tacacs_profiles_api.fetch_tacacs_server_profiles(
+ name=clean_tacacs_profile.name,
+ folder=clean_tacacs_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found tacacs_server_profiles '{clean_tacacs_profile.name}'"
+ assert fetched_obj.id == clean_tacacs_profile.id
+ assert fetched_obj.name == clean_tacacs_profile.name
+ assert fetched_obj.folder == clean_tacacs_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_tacacs_server_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent tacacs_server_profiles (should return None)
+ not_found = tacacs_profiles_api.fetch_tacacs_server_profiles(
+ name="non-existent-tacacs-server-profiles-xyz-12345",
+ folder=clean_tacacs_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent tacacs_server_profiles"
+ logger.info(f"\n[SUCCESS] fetch_tacacs_server_profiles correctly returned None for non-existent tacacs_server_profiles")
+
+
+def test_delete_tacacs_profile_by_id(tacacs_profiles_api):
+ """
+ Test deletion specifically with logging.
+ Mirrors Test_identity_services_TACACSServerProfilesAPIService_DeleteByID
+ """
+ object_name = f"test-tacacs-del-{uuid.uuid4().hex[:6]}"
+
+ server = TacacsServerProfilesServerInner(
+ name="del-test-svr",
+ address="3.3.3.3",
+ secret="delSecret"
+ )
+
+ payload = TacacsServerProfiles(
+ id="",
+ name=object_name,
+ folder=TARGET_FOLDER,
+ protocol="CHAP",
+ server=[server]
+ )
+
+ created_obj = perform(
+ tacacs_profiles_api.create_tacacs_server_profiles_with_http_info,
+ response_type=TacacsServerProfiles,
+ tacacs_server_profiles=payload
+ )
+
+ # Perform Delete
+ perform(
+ tacacs_profiles_api.delete_tacacs_server_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ # Verify Deletion
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ tacacs_profiles_api.get_tacacs_server_profiles_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ logger.info(f"Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_tls_service_profiles_test.py b/scm/identity_services/tests/api_tls_service_profiles_test.py
new file mode 100644
index 00000000..4ce361a0
--- /dev/null
+++ b/scm/identity_services/tests/api_tls_service_profiles_test.py
@@ -0,0 +1,215 @@
+import logging
+import uuid
+import json
+import pytest
+from scm import Scm
+from scm.identity_services.models.tls_service_profiles import TlsServiceProfiles
+from scm.identity_services.models.tls_service_profiles_protocol_settings import TlsServiceProfilesProtocolSettings
+from scm.test_helpers import perform
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# CONFIGURATION
+# -----------------------------------------------------------------------------
+TARGET_FOLDER = "All"
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+@pytest.fixture(scope="module")
+def tls_profiles_api(client):
+ return client.identity_services.TLSServiceProfilesApi(client.identity_services.api_client)
+
+@pytest.fixture
+def clean_tls_profile(tls_profiles_api):
+ profile_name = f"test-tls-prof-{uuid.uuid4().hex[:6]}"
+
+ protocol_settings = TlsServiceProfilesProtocolSettings(
+ min_version="tls1-1", # Explicitly set to valid enum value
+ max_version="tls1-3", # Explicitly set to valid enum value
+ keyxchg_algo_rsa=True,
+ keyxchg_algo_ecdhe=True,
+ keyxchg_algo_dhe=True,
+ enc_algo_aes_128_gcm=True,
+ enc_algo_aes_256_gcm=True,
+ enc_algo_aes_256_cbc=True,
+ auth_algo_sha256=True
+ )
+
+ payload = TlsServiceProfiles(
+ id="", # Workaround: id incorrectly marked as required in model
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ certificate="Forward-Trust-CA",
+ protocol_settings=protocol_settings
+ )
+
+ logger.info(f"\n[SETUP] Creating TLS Service Profile: {profile_name}")
+ created_obj = perform(
+ tls_profiles_api.create_tls_service_profiles_with_http_info,
+ tls_service_profiles=payload
+ )
+
+ yield created_obj
+
+ logger.info(f"\n[TEARDOWN] Deleting TLS Service Profile ID: {created_obj.id}")
+ try:
+ perform(
+ tls_profiles_api.delete_tls_service_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+ except Exception as e:
+ logger.info(f"Teardown failed: {e}")
+
+
+def test_create_tls_profile(tls_profiles_api):
+ profile_name = f"test-tls-create-{uuid.uuid4().hex[:6]}"
+
+ protocol_settings = TlsServiceProfilesProtocolSettings(
+ keyxchg_algo_rsa=True,
+ min_version=None, # Workaround: auto-generated model has invalid defaults '2' and '3'
+ max_version=None # See CLAUDE_README.md for details
+ )
+
+ payload = TlsServiceProfiles(
+ id="", # Workaround: id incorrectly marked as required in model
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ certificate="Forward-UnTrust-CA",
+ protocol_settings=protocol_settings
+ )
+
+ created_obj = perform(
+ tls_profiles_api.create_tls_service_profiles_with_http_info,
+ tls_service_profiles=payload
+ )
+
+ assert created_obj is not None
+ assert created_obj.id is not None
+ assert created_obj.name == profile_name
+
+ perform(
+ tls_profiles_api.delete_tls_service_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+
+def test_get_tls_profile_by_id(tls_profiles_api, clean_tls_profile):
+ fetched_obj = perform(
+ tls_profiles_api.get_tls_service_profiles_by_id_with_http_info,
+ id=clean_tls_profile.id
+ )
+
+ assert fetched_obj.id == clean_tls_profile.id
+ assert fetched_obj.name == clean_tls_profile.name
+
+
+def test_update_tls_profile(tls_profiles_api, clean_tls_profile):
+ update_payload = clean_tls_profile
+ update_payload.protocol_settings.min_version = "tls1-0"
+ update_payload.protocol_settings.max_version = "tls1-2"
+
+ updated_obj = perform(
+ tls_profiles_api.update_tls_service_profiles_by_id_with_http_info,
+ id=clean_tls_profile.id,
+ tls_service_profiles=update_payload
+ )
+
+ assert updated_obj.id == clean_tls_profile.id
+ assert updated_obj.protocol_settings.min_version == "tls1-0"
+ assert updated_obj.protocol_settings.max_version == "tls1-2"
+
+
+def test_list_tls_profiles(tls_profiles_api, clean_tls_profile):
+ response = perform(
+ tls_profiles_api.list_tls_service_profiles_with_http_info,
+ folder=TARGET_FOLDER
+ )
+
+ assert response is not None
+ assert len(response.data) > 0
+
+ found = False
+ for item in response.data:
+ if item.id == clean_tls_profile.id:
+ found = True
+ break
+ assert found is True, f"Created profile {clean_tls_profile.id} not found in list response"
+
+
+
+
+def test_fetch_tls_service_profiles(tls_profiles_api, clean_tls_profile):
+ """
+ Test fetching a single tls_service_profiles by name using the fetch convenience method.
+ Equivalent to pan-scm-sdk's fetch() method.
+ """
+ # Fetch by exact name
+ fetched_obj = tls_profiles_api.fetch_tls_service_profiles(
+ name=clean_tls_profile.name,
+ folder=clean_tls_profile.folder
+ )
+
+ # Verify
+ assert fetched_obj is not None, f"Should have found tls_service_profiles '{clean_tls_profile.name}'"
+ assert fetched_obj.id == clean_tls_profile.id
+ assert fetched_obj.name == clean_tls_profile.name
+ assert fetched_obj.folder == clean_tls_profile.folder
+ logger.info(f"\n[SUCCESS] fetch_tls_service_profiles found object: {fetched_obj.name}")
+
+ # Test fetching non-existent tls_service_profiles (should return None)
+ not_found = tls_profiles_api.fetch_tls_service_profiles(
+ name="non-existent-tls_service_profiles-xyz-12345",
+ folder=clean_tls_profile.folder
+ )
+ assert not_found is None, "Should return None for non-existent tls_service_profiles"
+ logger.info(f"\n[SUCCESS] fetch_tls_service_profiles correctly returned None for non-existent tls_service_profiles")
+
+
+def test_delete_tls_profile_by_id(tls_profiles_api):
+ profile_name = f"test-tls-del-{uuid.uuid4().hex[:6]}"
+
+ protocol_settings = TlsServiceProfilesProtocolSettings(
+ keyxchg_algo_rsa=True,
+ min_version=None, # Workaround: auto-generated model has invalid defaults '2' and '3'
+ max_version=None # See CLAUDE_README.md for details
+ )
+
+ payload = TlsServiceProfiles(
+ id="", # Workaround: id incorrectly marked as required in model
+ name=profile_name,
+ folder=TARGET_FOLDER,
+ certificate="Forward-UnTrust-CA",
+ protocol_settings=protocol_settings
+ )
+
+ created_obj = perform(
+ tls_profiles_api.create_tls_service_profiles_with_http_info,
+ tls_service_profiles=payload
+ )
+
+ perform(
+ tls_profiles_api.delete_tls_service_profiles_by_id_with_http_info,
+ id=created_obj.id
+ )
+
+ from scm.identity_services.exceptions import NotFoundException
+ from scm.error_parser import parse_scm_error
+ from scm.exceptions import ObjectNotPresentError
+
+ try:
+ tls_profiles_api.get_tls_service_profiles_by_id_with_http_info(id=created_obj.id)
+ pytest.fail("Profile should have been deleted but was found.")
+ except ObjectNotPresentError as e:
+ # Exception is already parsed by decorator
+ logger.info(f"✅ Correctly raised ObjectNotPresentError for deleted object")
+ logger.info(f" Object ID: {created_obj.id}")
diff --git a/scm/identity_services/tests/api_trusted_certificate_authorities_test.py b/scm/identity_services/tests/api_trusted_certificate_authorities_test.py
new file mode 100644
index 00000000..788b4d0c
--- /dev/null
+++ b/scm/identity_services/tests/api_trusted_certificate_authorities_test.py
@@ -0,0 +1,28 @@
+
+import logging
+import pytest
+from scm import Scm
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture(scope="module")
+def client():
+ try:
+ return Scm(log_level="DEBUG")
+ except Exception as e:
+ pytest.skip(f"Skipping tests due to client initialization failure: {e}")
+
+
+@pytest.fixture(scope="module")
+def trusted_certificate_authorities_api(client):
+ return client.identity_services.TrustedCertificateAuthoritiesApi(client.identity_services.api_client)
+
+
+def test_list_trusted_certificate_authorities(trusted_certificate_authorities_api):
+ """Test listing Trusted Certificate Authorities."""
+ response = trusted_certificate_authorities_api.list_trusted_certificate_authorities(limit=200, offset=0)
+ assert response is not None
+ assert response.data is not None and len(response.data) > 0
+ logger.info(f"Listed {len(response.data)} Trusted Certificate Authorities successfully")
diff --git a/scm/network_services/__init__.py b/scm/network_services/__init__.py
new file mode 100644
index 00000000..797a9baa
--- /dev/null
+++ b/scm/network_services/__init__.py
@@ -0,0 +1,637 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from scm.network_services.api.aggregate_interfaces_api import AggregateInterfacesApi
+from scm.network_services.api.auto_vpn_clusters_api import AutoVPNClustersApi
+from scm.network_services.api.auto_vpn_config_push_api import AutoVPNConfigPushApi
+from scm.network_services.api.auto_vpn_monitor_api import AutoVPNMonitorApi
+from scm.network_services.api.auto_vpn_settings_api import AutoVPNSettingsApi
+from scm.network_services.api.bgp_address_family_profiles_api import BGPAddressFamilyProfilesApi
+from scm.network_services.api.bgp_authentication_profiles_api import BGPAuthenticationProfilesApi
+from scm.network_services.api.bgp_filtering_profiles_api import BGPFilteringProfilesApi
+from scm.network_services.api.bgp_redistribution_profiles_api import BGPRedistributionProfilesApi
+from scm.network_services.api.bgp_route_map_redistributions_api import BGPRouteMapRedistributionsApi
+from scm.network_services.api.bgp_route_maps_api import BGPRouteMapsApi
+from scm.network_services.api.config_match_list_api import ConfigMatchListApi
+from scm.network_services.api.dhcp_interfaces_api import DHCPInterfacesApi
+from scm.network_services.api.dns_proxies_api import DNSProxiesApi
+from scm.network_services.api.ethernet_interfaces_api import EthernetInterfacesApi
+from scm.network_services.api.globalprotect_match_list_api import GlobalprotectMatchListApi
+from scm.network_services.api.hipmatch_match_list_api import HipmatchMatchListApi
+from scm.network_services.api.ike_crypto_profiles_api import IKECryptoProfilesApi
+from scm.network_services.api.ike_gateways_api import IKEGatewaysApi
+from scm.network_services.api.ipsec_crypto_profiles_api import IPsecCryptoProfilesApi
+from scm.network_services.api.ipsec_tunnels_api import IPsecTunnelsApi
+from scm.network_services.api.interface_management_profiles_api import InterfaceManagementProfilesApi
+from scm.network_services.api.iptag_match_list_api import IptagMatchListApi
+from scm.network_services.api.lldp_profiles_api import LLDPProfilesApi
+from scm.network_services.api.layer2_subinterfaces_api import Layer2SubinterfacesApi
+from scm.network_services.api.layer3_subinterfaces_api import Layer3SubinterfacesApi
+from scm.network_services.api.link_tags_api import LinkTagsApi
+from scm.network_services.api.logical_routers_api import LogicalRoutersApi
+from scm.network_services.api.loopback_interfaces_api import LoopbackInterfacesApi
+from scm.network_services.api.nat_rules_api import NATRulesApi
+from scm.network_services.api.ospf_authentication_profiles_api import OSPFAuthenticationProfilesApi
+from scm.network_services.api.pbf_rules_api import PBFRulesApi
+from scm.network_services.api.qos_profiles_api import QoSProfilesApi
+from scm.network_services.api.qos_rules_api import QoSRulesApi
+from scm.network_services.api.remote_networks_license_api import RemoteNetworksLicenseApi
+from scm.network_services.api.route_access_lists_api import RouteAccessListsApi
+from scm.network_services.api.route_community_lists_api import RouteCommunityListsApi
+from scm.network_services.api.route_path_access_lists_api import RoutePathAccessListsApi
+from scm.network_services.api.route_prefix_lists_api import RoutePrefixListsApi
+from scm.network_services.api.sdwan_error_correction_profiles_api import SDWANErrorCorrectionProfilesApi
+from scm.network_services.api.sdwan_path_quality_profiles_api import SDWANPathQualityProfilesApi
+from scm.network_services.api.sdwan_rules_api import SDWANRulesApi
+from scm.network_services.api.sdwan_saas_quality_profiles_api import SDWANSaaSQualityProfilesApi
+from scm.network_services.api.sdwan_traffic_distribution_profiles_api import SDWANTrafficDistributionProfilesApi
+from scm.network_services.api.security_zones_api import SecurityZonesApi
+from scm.network_services.api.system_match_list_api import SystemMatchListApi
+from scm.network_services.api.tunnel_interfaces_api import TunnelInterfacesApi
+from scm.network_services.api.userid_match_list_api import UseridMatchListApi
+from scm.network_services.api.vlan_interfaces_api import VLANInterfacesApi
+from scm.network_services.api.zone_protection_profiles_api import ZoneProtectionProfilesApi
+
+# import ApiClient
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.api_client import ApiClient
+from scm.network_services.configuration import Configuration
+from scm.network_services.exceptions import OpenApiException
+from scm.network_services.exceptions import ApiTypeError
+from scm.network_services.exceptions import ApiValueError
+from scm.network_services.exceptions import ApiKeyError
+from scm.network_services.exceptions import ApiAttributeError
+from scm.network_services.exceptions import ApiException
+
+# import models into sdk package
+from scm.network_services.models.agg_ethernet_arp_inner import AggEthernetArpInner
+from scm.network_services.models.agg_ethernet_dhcp_client import AggEthernetDhcpClient
+from scm.network_services.models.agg_ethernet_dhcp_client_dhcp_client import AggEthernetDhcpClientDhcpClient
+from scm.network_services.models.agg_ethernet_dhcp_client_dhcp_client_send_hostname import AggEthernetDhcpClientDhcpClientSendHostname
+from scm.network_services.models.aggregate_interfaces import AggregateInterfaces
+from scm.network_services.models.aggregate_interfaces_layer2 import AggregateInterfacesLayer2
+from scm.network_services.models.aggregate_interfaces_layer3 import AggregateInterfacesLayer3
+from scm.network_services.models.aggregate_interfaces_layer3_ddns_config import AggregateInterfacesLayer3DdnsConfig
+from scm.network_services.models.aggregate_interfaces_layer3_ip_inner import AggregateInterfacesLayer3IpInner
+from scm.network_services.models.aggregate_interfaces_list_response import AggregateInterfacesListResponse
+from scm.network_services.models.auto_vpn_clusters_list_response import AutoVPNClustersListResponse
+from scm.network_services.models.auto_vpn_clusters import AutoVpnClusters
+from scm.network_services.models.auto_vpn_clusters_branches_inner import AutoVpnClustersBranchesInner
+from scm.network_services.models.auto_vpn_clusters_branches_inner_interfaces_inner import AutoVpnClustersBranchesInnerInterfacesInner
+from scm.network_services.models.auto_vpn_clusters_branches_inner_interfaces_inner_sdwan_link_settings import AutoVpnClustersBranchesInnerInterfacesInnerSdwanLinkSettings
+from scm.network_services.models.auto_vpn_clusters_branches_inner_interfaces_inner_sdwan_link_settings_upstream_nat import AutoVpnClustersBranchesInnerInterfacesInnerSdwanLinkSettingsUpstreamNat
+from scm.network_services.models.auto_vpn_clusters_branches_inner_interfaces_inner_sdwan_link_settings_upstream_nat_static_ip import AutoVpnClustersBranchesInnerInterfacesInnerSdwanLinkSettingsUpstreamNatStaticIp
+from scm.network_services.models.auto_vpn_clusters_branches_inner_private_interfaces_inner import AutoVpnClustersBranchesInnerPrivateInterfacesInner
+from scm.network_services.models.auto_vpn_clusters_gateways_inner import AutoVpnClustersGatewaysInner
+from scm.network_services.models.auto_vpn_clusters_gateways_inner_interfaces_inner import AutoVpnClustersGatewaysInnerInterfacesInner
+from scm.network_services.models.auto_vpn_clusters_gateways_inner_interfaces_inner_sdwan_link_settings import AutoVpnClustersGatewaysInnerInterfacesInnerSdwanLinkSettings
+from scm.network_services.models.auto_vpn_clusters_gateways_inner_interfaces_inner_sdwan_link_settings_upstream_nat import AutoVpnClustersGatewaysInnerInterfacesInnerSdwanLinkSettingsUpstreamNat
+from scm.network_services.models.auto_vpn_clusters_gateways_inner_private_interfaces_inner import AutoVpnClustersGatewaysInnerPrivateInterfacesInner
+from scm.network_services.models.auto_vpn_monitor import AutoVpnMonitor
+from scm.network_services.models.auto_vpn_push_config import AutoVpnPushConfig
+from scm.network_services.models.auto_vpn_push_config_auto_vpn_devices_inner import AutoVpnPushConfigAutoVpnDevicesInner
+from scm.network_services.models.auto_vpn_push_response import AutoVpnPushResponse
+from scm.network_services.models.auto_vpn_settings import AutoVpnSettings
+from scm.network_services.models.auto_vpn_settings_as_range import AutoVpnSettingsAsRange
+from scm.network_services.models.bgp_address_family_profiles_list_response import BGPAddressFamilyProfilesListResponse
+from scm.network_services.models.bgp_authentication_profiles_list_response import BGPAuthenticationProfilesListResponse
+from scm.network_services.models.bgp_filtering_profiles_list_response import BGPFilteringProfilesListResponse
+from scm.network_services.models.bgp_redistribution_profiles_list_response import BGPRedistributionProfilesListResponse
+from scm.network_services.models.bgp_route_map_redistributions_list_response import BGPRouteMapRedistributionsListResponse
+from scm.network_services.models.bgp_route_maps_list_response import BGPRouteMapsListResponse
+from scm.network_services.models.bgp_address_family import BgpAddressFamily
+from scm.network_services.models.bgp_address_family_add_path import BgpAddressFamilyAddPath
+from scm.network_services.models.bgp_address_family_allowas_in import BgpAddressFamilyAllowasIn
+from scm.network_services.models.bgp_address_family_maximum_prefix import BgpAddressFamilyMaximumPrefix
+from scm.network_services.models.bgp_address_family_maximum_prefix_action import BgpAddressFamilyMaximumPrefixAction
+from scm.network_services.models.bgp_address_family_maximum_prefix_action_restart import BgpAddressFamilyMaximumPrefixActionRestart
+from scm.network_services.models.bgp_address_family_next_hop import BgpAddressFamilyNextHop
+from scm.network_services.models.bgp_address_family_orf import BgpAddressFamilyOrf
+from scm.network_services.models.bgp_address_family_profiles import BgpAddressFamilyProfiles
+from scm.network_services.models.bgp_address_family_profiles_ipv4 import BgpAddressFamilyProfilesIpv4
+from scm.network_services.models.bgp_address_family_remove_private_as import BgpAddressFamilyRemovePrivateAS
+from scm.network_services.models.bgp_address_family_send_community import BgpAddressFamilySendCommunity
+from scm.network_services.models.bgp_auth_profiles import BgpAuthProfiles
+from scm.network_services.models.bgp_filter import BgpFilter
+from scm.network_services.models.bgp_filter_conditional_advertisement import BgpFilterConditionalAdvertisement
+from scm.network_services.models.bgp_filter_conditional_advertisement_exist import BgpFilterConditionalAdvertisementExist
+from scm.network_services.models.bgp_filter_conditional_advertisement_non_exist import BgpFilterConditionalAdvertisementNonExist
+from scm.network_services.models.bgp_filter_filter_list import BgpFilterFilterList
+from scm.network_services.models.bgp_filter_inbound_network_filters import BgpFilterInboundNetworkFilters
+from scm.network_services.models.bgp_filtering_profiles import BgpFilteringProfiles
+from scm.network_services.models.bgp_filtering_profiles_ipv4 import BgpFilteringProfilesIpv4
+from scm.network_services.models.bgp_filtering_profiles_ipv4_multicast import BgpFilteringProfilesIpv4Multicast
+from scm.network_services.models.bgp_redistribution_profiles import BgpRedistributionProfiles
+from scm.network_services.models.bgp_redistribution_profiles_ipv4 import BgpRedistributionProfilesIpv4
+from scm.network_services.models.bgp_redistribution_profiles_ipv4_unicast import BgpRedistributionProfilesIpv4Unicast
+from scm.network_services.models.bgp_redistribution_profiles_ipv4_unicast_connected import BgpRedistributionProfilesIpv4UnicastConnected
+from scm.network_services.models.bgp_redistribution_profiles_ipv4_unicast_ospf import BgpRedistributionProfilesIpv4UnicastOspf
+from scm.network_services.models.bgp_redistribution_profiles_ipv4_unicast_static import BgpRedistributionProfilesIpv4UnicastStatic
+from scm.network_services.models.bgp_route_map_redistributions import BgpRouteMapRedistributions
+from scm.network_services.models.bgp_route_map_redistributions_bgp import BgpRouteMapRedistributionsBgp
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf import BgpRouteMapRedistributionsBgpOspf
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner import BgpRouteMapRedistributionsBgpOspfRouteMapInner
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner_match import BgpRouteMapRedistributionsBgpOspfRouteMapInnerMatch
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner_match_ipv4 import BgpRouteMapRedistributionsBgpOspfRouteMapInnerMatchIpv4
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner_match_ipv4_address import BgpRouteMapRedistributionsBgpOspfRouteMapInnerMatchIpv4Address
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner_match_ipv4_next_hop import BgpRouteMapRedistributionsBgpOspfRouteMapInnerMatchIpv4NextHop
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner_match_ipv4_route_source import BgpRouteMapRedistributionsBgpOspfRouteMapInnerMatchIpv4RouteSource
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner_set import BgpRouteMapRedistributionsBgpOspfRouteMapInnerSet
+from scm.network_services.models.bgp_route_map_redistributions_bgp_ospf_route_map_inner_set_metric import BgpRouteMapRedistributionsBgpOspfRouteMapInnerSetMetric
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib import BgpRouteMapRedistributionsBgpRib
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib_route_map_inner import BgpRouteMapRedistributionsBgpRibRouteMapInner
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib_route_map_inner_match import BgpRouteMapRedistributionsBgpRibRouteMapInnerMatch
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib_route_map_inner_match_ipv4 import BgpRouteMapRedistributionsBgpRibRouteMapInnerMatchIpv4
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib_route_map_inner_match_ipv4_address import BgpRouteMapRedistributionsBgpRibRouteMapInnerMatchIpv4Address
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib_route_map_inner_match_ipv4_next_hop import BgpRouteMapRedistributionsBgpRibRouteMapInnerMatchIpv4NextHop
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib_route_map_inner_match_ipv4_route_source import BgpRouteMapRedistributionsBgpRibRouteMapInnerMatchIpv4RouteSource
+from scm.network_services.models.bgp_route_map_redistributions_bgp_rib_route_map_inner_set import BgpRouteMapRedistributionsBgpRibRouteMapInnerSet
+from scm.network_services.models.bgp_route_map_redistributions_connected_static import BgpRouteMapRedistributionsConnectedStatic
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp import BgpRouteMapRedistributionsConnectedStaticBgp
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInner
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_match import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerMatch
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_match_ipv4 import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerMatchIpv4
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_match_ipv4_address import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerMatchIpv4Address
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_match_ipv4_next_hop import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerMatchIpv4NextHop
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_set import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerSet
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_set_aggregator import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerSetAggregator
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_set_ipv4 import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerSetIpv4
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_bgp_route_map_inner_set_metric import BgpRouteMapRedistributionsConnectedStaticBgpRouteMapInnerSetMetric
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf import BgpRouteMapRedistributionsConnectedStaticOspf
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf_route_map_inner import BgpRouteMapRedistributionsConnectedStaticOspfRouteMapInner
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf_route_map_inner_match import BgpRouteMapRedistributionsConnectedStaticOspfRouteMapInnerMatch
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf_route_map_inner_match_ipv4 import BgpRouteMapRedistributionsConnectedStaticOspfRouteMapInnerMatchIpv4
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf_route_map_inner_match_ipv4_address import BgpRouteMapRedistributionsConnectedStaticOspfRouteMapInnerMatchIpv4Address
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf_route_map_inner_match_ipv4_next_hop import BgpRouteMapRedistributionsConnectedStaticOspfRouteMapInnerMatchIpv4NextHop
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf_route_map_inner_set import BgpRouteMapRedistributionsConnectedStaticOspfRouteMapInnerSet
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_ospf_route_map_inner_set_metric import BgpRouteMapRedistributionsConnectedStaticOspfRouteMapInnerSetMetric
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_rib import BgpRouteMapRedistributionsConnectedStaticRib
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_rib_route_map_inner import BgpRouteMapRedistributionsConnectedStaticRibRouteMapInner
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_rib_route_map_inner_match import BgpRouteMapRedistributionsConnectedStaticRibRouteMapInnerMatch
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_rib_route_map_inner_match_ipv4 import BgpRouteMapRedistributionsConnectedStaticRibRouteMapInnerMatchIpv4
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_rib_route_map_inner_match_ipv4_address import BgpRouteMapRedistributionsConnectedStaticRibRouteMapInnerMatchIpv4Address
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_rib_route_map_inner_match_ipv4_next_hop import BgpRouteMapRedistributionsConnectedStaticRibRouteMapInnerMatchIpv4NextHop
+from scm.network_services.models.bgp_route_map_redistributions_connected_static_rib_route_map_inner_set import BgpRouteMapRedistributionsConnectedStaticRibRouteMapInnerSet
+from scm.network_services.models.bgp_route_map_redistributions_ospf import BgpRouteMapRedistributionsOspf
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp import BgpRouteMapRedistributionsOspfBgp
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner import BgpRouteMapRedistributionsOspfBgpRouteMapInner
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner_match import BgpRouteMapRedistributionsOspfBgpRouteMapInnerMatch
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner_match_address import BgpRouteMapRedistributionsOspfBgpRouteMapInnerMatchAddress
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner_match_next_hop import BgpRouteMapRedistributionsOspfBgpRouteMapInnerMatchNextHop
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner_set import BgpRouteMapRedistributionsOspfBgpRouteMapInnerSet
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner_set_aggregator import BgpRouteMapRedistributionsOspfBgpRouteMapInnerSetAggregator
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner_set_ipv4 import BgpRouteMapRedistributionsOspfBgpRouteMapInnerSetIpv4
+from scm.network_services.models.bgp_route_map_redistributions_ospf_bgp_route_map_inner_set_metric import BgpRouteMapRedistributionsOspfBgpRouteMapInnerSetMetric
+from scm.network_services.models.bgp_route_map_redistributions_ospf_rib import BgpRouteMapRedistributionsOspfRib
+from scm.network_services.models.bgp_route_map_redistributions_ospf_rib_route_map_inner import BgpRouteMapRedistributionsOspfRibRouteMapInner
+from scm.network_services.models.bgp_route_map_redistributions_ospf_rib_route_map_inner_match import BgpRouteMapRedistributionsOspfRibRouteMapInnerMatch
+from scm.network_services.models.bgp_route_map_redistributions_ospf_rib_route_map_inner_match_address import BgpRouteMapRedistributionsOspfRibRouteMapInnerMatchAddress
+from scm.network_services.models.bgp_route_map_redistributions_ospf_rib_route_map_inner_match_next_hop import BgpRouteMapRedistributionsOspfRibRouteMapInnerMatchNextHop
+from scm.network_services.models.bgp_route_map_redistributions_ospf_rib_route_map_inner_set import BgpRouteMapRedistributionsOspfRibRouteMapInnerSet
+from scm.network_services.models.bgp_route_maps import BgpRouteMaps
+from scm.network_services.models.bgp_route_maps_route_map_inner import BgpRouteMapsRouteMapInner
+from scm.network_services.models.bgp_route_maps_route_map_inner_match import BgpRouteMapsRouteMapInnerMatch
+from scm.network_services.models.bgp_route_maps_route_map_inner_match_ipv4 import BgpRouteMapsRouteMapInnerMatchIpv4
+from scm.network_services.models.bgp_route_maps_route_map_inner_match_ipv4_address import BgpRouteMapsRouteMapInnerMatchIpv4Address
+from scm.network_services.models.bgp_route_maps_route_map_inner_set import BgpRouteMapsRouteMapInnerSet
+from scm.network_services.models.bgp_route_maps_route_map_inner_set_aggregator import BgpRouteMapsRouteMapInnerSetAggregator
+from scm.network_services.models.bgp_route_maps_route_map_inner_set_ipv4 import BgpRouteMapsRouteMapInnerSetIpv4
+from scm.network_services.models.bgp_route_maps_route_map_inner_set_metric import BgpRouteMapsRouteMapInnerSetMetric
+from scm.network_services.models.config_match_list import ConfigMatchList
+from scm.network_services.models.config_match_list_list_response import ConfigMatchListListResponse
+from scm.network_services.models.dhcp_interfaces_list_response import DHCPInterfacesListResponse
+from scm.network_services.models.dns_proxies_list_response import DNSProxiesListResponse
+from scm.network_services.models.ddns_config import DdnsConfig
+from scm.network_services.models.dhcp_interfaces import DhcpInterfaces
+from scm.network_services.models.dhcp_interfaces_relay import DhcpInterfacesRelay
+from scm.network_services.models.dhcp_interfaces_relay_ip import DhcpInterfacesRelayIp
+from scm.network_services.models.dhcp_interfaces_server import DhcpInterfacesServer
+from scm.network_services.models.dhcp_interfaces_server_option import DhcpInterfacesServerOption
+from scm.network_services.models.dhcp_interfaces_server_option_dns import DhcpInterfacesServerOptionDns
+from scm.network_services.models.dhcp_interfaces_server_option_inheritance import DhcpInterfacesServerOptionInheritance
+from scm.network_services.models.dhcp_interfaces_server_option_lease import DhcpInterfacesServerOptionLease
+from scm.network_services.models.dhcp_interfaces_server_option_nis import DhcpInterfacesServerOptionNis
+from scm.network_services.models.dhcp_interfaces_server_option_ntp import DhcpInterfacesServerOptionNtp
+from scm.network_services.models.dhcp_interfaces_server_option_user_defined_inner import DhcpInterfacesServerOptionUserDefinedInner
+from scm.network_services.models.dhcp_interfaces_server_option_wins import DhcpInterfacesServerOptionWins
+from scm.network_services.models.dhcp_interfaces_server_reserved_inner import DhcpInterfacesServerReservedInner
+from scm.network_services.models.dns_proxies import DnsProxies
+from scm.network_services.models.dns_proxies_cache import DnsProxiesCache
+from scm.network_services.models.dns_proxies_cache_max_ttl import DnsProxiesCacheMaxTtl
+from scm.network_services.models.dns_proxies_default import DnsProxiesDefault
+from scm.network_services.models.dns_proxies_default_inheritance import DnsProxiesDefaultInheritance
+from scm.network_services.models.dns_proxies_domain_servers_inner import DnsProxiesDomainServersInner
+from scm.network_services.models.dns_proxies_static_entries_inner import DnsProxiesStaticEntriesInner
+from scm.network_services.models.dns_proxies_tcp_queries import DnsProxiesTcpQueries
+from scm.network_services.models.dns_proxies_udp_queries import DnsProxiesUdpQueries
+from scm.network_services.models.dns_proxies_udp_queries_retries import DnsProxiesUdpQueriesRetries
+from scm.network_services.models.error_detail_cause_info import ErrorDetailCauseInfo
+from scm.network_services.models.ethernet_interfaces import EthernetInterfaces
+from scm.network_services.models.ethernet_interfaces_arp_inner import EthernetInterfacesArpInner
+from scm.network_services.models.ethernet_interfaces_dhcp_client import EthernetInterfacesDhcpClient
+from scm.network_services.models.ethernet_interfaces_layer2 import EthernetInterfacesLayer2
+from scm.network_services.models.ethernet_interfaces_layer2_lldp import EthernetInterfacesLayer2Lldp
+from scm.network_services.models.ethernet_interfaces_layer3 import EthernetInterfacesLayer3
+from scm.network_services.models.ethernet_interfaces_layer3_ddns_config import EthernetInterfacesLayer3DdnsConfig
+from scm.network_services.models.ethernet_interfaces_layer3_dhcp_client import EthernetInterfacesLayer3DhcpClient
+from scm.network_services.models.ethernet_interfaces_layer3_dhcp_client_send_hostname import EthernetInterfacesLayer3DhcpClientSendHostname
+from scm.network_services.models.ethernet_interfaces_layer3_ip_inner import EthernetInterfacesLayer3IpInner
+from scm.network_services.models.ethernet_interfaces_layer3_pppoe import EthernetInterfacesLayer3Pppoe
+from scm.network_services.models.ethernet_interfaces_layer3_pppoe_passive import EthernetInterfacesLayer3PppoePassive
+from scm.network_services.models.ethernet_interfaces_layer3_pppoe_static_address import EthernetInterfacesLayer3PppoeStaticAddress
+from scm.network_services.models.ethernet_interfaces_list_response import EthernetInterfacesListResponse
+from scm.network_services.models.ethernet_interfaces_tap import EthernetInterfacesTap
+from scm.network_services.models.generic_error import GenericError
+from scm.network_services.models.get_auto_vpn_monitor200_response import GetAutoVPNMonitor200Response
+from scm.network_services.models.get_remote_networks_license_info500_response import GetRemoteNetworksLicenseInfo500Response
+from scm.network_services.models.globalprotect_match_list import GlobalprotectMatchList
+from scm.network_services.models.globalprotect_match_list_list_response import GlobalprotectMatchListListResponse
+from scm.network_services.models.hipmatch_match_list import HipmatchMatchList
+from scm.network_services.models.hipmatch_match_list_list_response import HipmatchMatchListListResponse
+from scm.network_services.models.ike_crypto_profiles_list_response import IKECryptoProfilesListResponse
+from scm.network_services.models.ike_gateways_list_response import IKEGatewaysListResponse
+from scm.network_services.models.ipsec_crypto_profiles_list_response import IPsecCryptoProfilesListResponse
+from scm.network_services.models.ipsec_tunnels_list_response import IPsecTunnelsListResponse
+from scm.network_services.models.ike_crypto_profiles import IkeCryptoProfiles
+from scm.network_services.models.ike_crypto_profiles_lifetime import IkeCryptoProfilesLifetime
+from scm.network_services.models.ike_gateways import IkeGateways
+from scm.network_services.models.ike_gateways_authentication import IkeGatewaysAuthentication
+from scm.network_services.models.ike_gateways_authentication_certificate import IkeGatewaysAuthenticationCertificate
+from scm.network_services.models.ike_gateways_authentication_certificate_local_certificate import IkeGatewaysAuthenticationCertificateLocalCertificate
+from scm.network_services.models.ike_gateways_authentication_pre_shared_key import IkeGatewaysAuthenticationPreSharedKey
+from scm.network_services.models.ike_gateways_local_address import IkeGatewaysLocalAddress
+from scm.network_services.models.ike_gateways_local_id import IkeGatewaysLocalId
+from scm.network_services.models.ike_gateways_peer_address import IkeGatewaysPeerAddress
+from scm.network_services.models.ike_gateways_peer_id import IkeGatewaysPeerId
+from scm.network_services.models.ike_gateways_protocol import IkeGatewaysProtocol
+from scm.network_services.models.ike_gateways_protocol_common import IkeGatewaysProtocolCommon
+from scm.network_services.models.ike_gateways_protocol_common_fragmentation import IkeGatewaysProtocolCommonFragmentation
+from scm.network_services.models.ike_gateways_protocol_common_nat_traversal import IkeGatewaysProtocolCommonNatTraversal
+from scm.network_services.models.ike_gateways_protocol_ikev1 import IkeGatewaysProtocolIkev1
+from scm.network_services.models.ike_gateways_protocol_ikev1_dpd import IkeGatewaysProtocolIkev1Dpd
+from scm.network_services.models.interface_management_profiles import InterfaceManagementProfiles
+from scm.network_services.models.interface_management_profiles_list_response import InterfaceManagementProfilesListResponse
+from scm.network_services.models.interface_management_profiles_permitted_ip_inner import InterfaceManagementProfilesPermittedIpInner
+from scm.network_services.models.ipsec_crypto_profiles import IpsecCryptoProfiles
+from scm.network_services.models.ipsec_crypto_profiles_ah import IpsecCryptoProfilesAh
+from scm.network_services.models.ipsec_crypto_profiles_esp import IpsecCryptoProfilesEsp
+from scm.network_services.models.ipsec_crypto_profiles_lifesize import IpsecCryptoProfilesLifesize
+from scm.network_services.models.ipsec_crypto_profiles_lifetime import IpsecCryptoProfilesLifetime
+from scm.network_services.models.ipsec_tunnels import IpsecTunnels
+from scm.network_services.models.ipsec_tunnels_auto_key import IpsecTunnelsAutoKey
+from scm.network_services.models.ipsec_tunnels_auto_key_ike_gateway_inner import IpsecTunnelsAutoKeyIkeGatewayInner
+from scm.network_services.models.ipsec_tunnels_auto_key_proxy_id_inner import IpsecTunnelsAutoKeyProxyIdInner
+from scm.network_services.models.ipsec_tunnels_auto_key_proxy_id_inner_protocol import IpsecTunnelsAutoKeyProxyIdInnerProtocol
+from scm.network_services.models.ipsec_tunnels_auto_key_proxy_id_inner_protocol_tcp import IpsecTunnelsAutoKeyProxyIdInnerProtocolTcp
+from scm.network_services.models.ipsec_tunnels_auto_key_proxy_id_inner_protocol_udp import IpsecTunnelsAutoKeyProxyIdInnerProtocolUdp
+from scm.network_services.models.ipsec_tunnels_auto_key_proxy_id_v6_inner import IpsecTunnelsAutoKeyProxyIdV6Inner
+from scm.network_services.models.ipsec_tunnels_auto_key_proxy_id_v6_inner_protocol import IpsecTunnelsAutoKeyProxyIdV6InnerProtocol
+from scm.network_services.models.ipsec_tunnels_auto_key_proxy_id_v6_inner_protocol_tcp import IpsecTunnelsAutoKeyProxyIdV6InnerProtocolTcp
+from scm.network_services.models.ipsec_tunnels_tunnel_monitor import IpsecTunnelsTunnelMonitor
+from scm.network_services.models.iptag_match_list import IptagMatchList
+from scm.network_services.models.iptag_match_list_list_response import IptagMatchListListResponse
+from scm.network_services.models.lldp_profiles_list_response import LLDPProfilesListResponse
+from scm.network_services.models.lacp import Lacp
+from scm.network_services.models.layer2_subinterfaces import Layer2Subinterfaces
+from scm.network_services.models.layer2_subinterfaces_list_response import Layer2SubinterfacesListResponse
+from scm.network_services.models.layer3_sub_interfaces_dhcp_client import Layer3SubInterfacesDhcpClient
+from scm.network_services.models.layer3_sub_interfaces_dhcp_client_dhcp_client import Layer3SubInterfacesDhcpClientDhcpClient
+from scm.network_services.models.layer3_sub_interfaces_dhcp_client_dhcp_client_send_hostname import Layer3SubInterfacesDhcpClientDhcpClientSendHostname
+from scm.network_services.models.layer3_subinterfaces import Layer3Subinterfaces
+from scm.network_services.models.layer3_subinterfaces_arp_inner import Layer3SubinterfacesArpInner
+from scm.network_services.models.layer3_subinterfaces_ddns_config import Layer3SubinterfacesDdnsConfig
+from scm.network_services.models.layer3_subinterfaces_ip_inner import Layer3SubinterfacesIpInner
+from scm.network_services.models.layer3_subinterfaces_list_response import Layer3SubinterfacesListResponse
+from scm.network_services.models.license_info import LicenseInfo
+from scm.network_services.models.license_result import LicenseResult
+from scm.network_services.models.link_tags import LinkTags
+from scm.network_services.models.link_tags_list_response import LinkTagsListResponse
+from scm.network_services.models.lldp_profiles import LldpProfiles
+from scm.network_services.models.lldp_profiles_option_tlvs import LldpProfilesOptionTlvs
+from scm.network_services.models.lldp_profiles_option_tlvs_management_address import LldpProfilesOptionTlvsManagementAddress
+from scm.network_services.models.lldp_profiles_option_tlvs_management_address_iplist_inner import LldpProfilesOptionTlvsManagementAddressIplistInner
+from scm.network_services.models.logical_routers import LogicalRouters
+from scm.network_services.models.logical_routers_list_response import LogicalRoutersListResponse
+from scm.network_services.models.logical_routers_vrf_inner import LogicalRoutersVrfInner
+from scm.network_services.models.logical_routers_vrf_inner_admin_dists import LogicalRoutersVrfInnerAdminDists
+from scm.network_services.models.logical_routers_vrf_inner_bgp import LogicalRoutersVrfInnerBgp
+from scm.network_services.models.logical_routers_vrf_inner_bgp_advertise_network import LogicalRoutersVrfInnerBgpAdvertiseNetwork
+from scm.network_services.models.logical_routers_vrf_inner_bgp_advertise_network_ipv4 import LogicalRoutersVrfInnerBgpAdvertiseNetworkIpv4
+from scm.network_services.models.logical_routers_vrf_inner_bgp_advertise_network_ipv4_network_inner import LogicalRoutersVrfInnerBgpAdvertiseNetworkIpv4NetworkInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_advertise_network_ipv6 import LogicalRoutersVrfInnerBgpAdvertiseNetworkIpv6
+from scm.network_services.models.logical_routers_vrf_inner_bgp_advertise_network_ipv6_network_inner import LogicalRoutersVrfInnerBgpAdvertiseNetworkIpv6NetworkInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_aggregate import LogicalRoutersVrfInnerBgpAggregate
+from scm.network_services.models.logical_routers_vrf_inner_bgp_aggregate_routes_inner import LogicalRoutersVrfInnerBgpAggregateRoutesInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_aggregate_routes_inner_type import LogicalRoutersVrfInnerBgpAggregateRoutesInnerType
+from scm.network_services.models.logical_routers_vrf_inner_bgp_aggregate_routes_inner_type_ipv4 import LogicalRoutersVrfInnerBgpAggregateRoutesInnerTypeIpv4
+from scm.network_services.models.logical_routers_vrf_inner_bgp_global_bfd import LogicalRoutersVrfInnerBgpGlobalBfd
+from scm.network_services.models.logical_routers_vrf_inner_bgp_graceful_restart import LogicalRoutersVrfInnerBgpGracefulRestart
+from scm.network_services.models.logical_routers_vrf_inner_bgp_med import LogicalRoutersVrfInnerBgpMed
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner import LogicalRoutersVrfInnerBgpPeerGroupInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_address_family import LogicalRoutersVrfInnerBgpPeerGroupInnerAddressFamily
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_connection_options import LogicalRoutersVrfInnerBgpPeerGroupInnerConnectionOptions
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_bfd import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerBfd
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_bfd_multihop import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerBfdMultihop
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_connection_options import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerConnectionOptions
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_connection_options_incoming_bgp_connection import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerConnectionOptionsIncomingBgpConnection
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_connection_options_outgoing_bgp_connection import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerConnectionOptionsOutgoingBgpConnection
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_inherit import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerInherit
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_inherit_no import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerInheritNo
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_local_address import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerLocalAddress
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_peer_address import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerPeerAddress
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_peer_inner_subsequent_address_family_identifier import LogicalRoutersVrfInnerBgpPeerGroupInnerPeerInnerSubsequentAddressFamilyIdentifier
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_type import LogicalRoutersVrfInnerBgpPeerGroupInnerType
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_type_ebgp import LogicalRoutersVrfInnerBgpPeerGroupInnerTypeEbgp
+from scm.network_services.models.logical_routers_vrf_inner_bgp_peer_group_inner_type_ebgp_confed import LogicalRoutersVrfInnerBgpPeerGroupInnerTypeEbgpConfed
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy import LogicalRoutersVrfInnerBgpPolicy
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation import LogicalRoutersVrfInnerBgpPolicyAggregation
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner_advertise_filters_inner import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInnerAdvertiseFiltersInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner_advertise_filters_inner_match import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInnerAdvertiseFiltersInnerMatch
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner_advertise_filters_inner_match_address_prefix_inner import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInnerAdvertiseFiltersInnerMatchAddressPrefixInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner_advertise_filters_inner_match_as_path import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInnerAdvertiseFiltersInnerMatchAsPath
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner_aggregate_route_attributes import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInnerAggregateRouteAttributes
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner_aggregate_route_attributes_as_path import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInnerAggregateRouteAttributesAsPath
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_aggregation_address_inner_aggregate_route_attributes_community import LogicalRoutersVrfInnerBgpPolicyAggregationAddressInnerAggregateRouteAttributesCommunity
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_conditional_advertisement import LogicalRoutersVrfInnerBgpPolicyConditionalAdvertisement
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_conditional_advertisement_policy_inner import LogicalRoutersVrfInnerBgpPolicyConditionalAdvertisementPolicyInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_export import LogicalRoutersVrfInnerBgpPolicyExport
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_export_rules_inner import LogicalRoutersVrfInnerBgpPolicyExportRulesInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_export_rules_inner_action import LogicalRoutersVrfInnerBgpPolicyExportRulesInnerAction
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_export_rules_inner_action_allow import LogicalRoutersVrfInnerBgpPolicyExportRulesInnerActionAllow
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_export_rules_inner_action_allow_update import LogicalRoutersVrfInnerBgpPolicyExportRulesInnerActionAllowUpdate
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_export_rules_inner_match import LogicalRoutersVrfInnerBgpPolicyExportRulesInnerMatch
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_export_rules_inner_match_address_prefix_inner import LogicalRoutersVrfInnerBgpPolicyExportRulesInnerMatchAddressPrefixInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_import import LogicalRoutersVrfInnerBgpPolicyImport
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_import_rules_inner import LogicalRoutersVrfInnerBgpPolicyImportRulesInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_import_rules_inner_action import LogicalRoutersVrfInnerBgpPolicyImportRulesInnerAction
+from scm.network_services.models.logical_routers_vrf_inner_bgp_policy_import_rules_inner_action_allow import LogicalRoutersVrfInnerBgpPolicyImportRulesInnerActionAllow
+from scm.network_services.models.logical_routers_vrf_inner_bgp_redist_rules_inner import LogicalRoutersVrfInnerBgpRedistRulesInner
+from scm.network_services.models.logical_routers_vrf_inner_bgp_redistribution_profile import LogicalRoutersVrfInnerBgpRedistributionProfile
+from scm.network_services.models.logical_routers_vrf_inner_bgp_redistribution_profile_ipv4 import LogicalRoutersVrfInnerBgpRedistributionProfileIpv4
+from scm.network_services.models.logical_routers_vrf_inner_ecmp import LogicalRoutersVrfInnerEcmp
+from scm.network_services.models.logical_routers_vrf_inner_ecmp_algorithm import LogicalRoutersVrfInnerEcmpAlgorithm
+from scm.network_services.models.logical_routers_vrf_inner_ecmp_algorithm_ip_hash import LogicalRoutersVrfInnerEcmpAlgorithmIpHash
+from scm.network_services.models.logical_routers_vrf_inner_ecmp_algorithm_weighted_round_robin import LogicalRoutersVrfInnerEcmpAlgorithmWeightedRoundRobin
+from scm.network_services.models.logical_routers_vrf_inner_ecmp_algorithm_weighted_round_robin_interface_inner import LogicalRoutersVrfInnerEcmpAlgorithmWeightedRoundRobinInterfaceInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast import LogicalRoutersVrfInnerMulticast
+from scm.network_services.models.logical_routers_vrf_inner_multicast_igmp import LogicalRoutersVrfInnerMulticastIgmp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_igmp_dynamic import LogicalRoutersVrfInnerMulticastIgmpDynamic
+from scm.network_services.models.logical_routers_vrf_inner_multicast_igmp_dynamic_interface_inner import LogicalRoutersVrfInnerMulticastIgmpDynamicInterfaceInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_igmp_static_inner import LogicalRoutersVrfInnerMulticastIgmpStaticInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_interface_group_inner import LogicalRoutersVrfInnerMulticastInterfaceGroupInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_interface_group_inner_group_permission import LogicalRoutersVrfInnerMulticastInterfaceGroupInnerGroupPermission
+from scm.network_services.models.logical_routers_vrf_inner_multicast_interface_group_inner_group_permission_any_source_multicast_inner import LogicalRoutersVrfInnerMulticastInterfaceGroupInnerGroupPermissionAnySourceMulticastInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_interface_group_inner_group_permission_source_specific_multicast_inner import LogicalRoutersVrfInnerMulticastInterfaceGroupInnerGroupPermissionSourceSpecificMulticastInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_interface_group_inner_igmp import LogicalRoutersVrfInnerMulticastInterfaceGroupInnerIgmp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_interface_group_inner_pim import LogicalRoutersVrfInnerMulticastInterfaceGroupInnerPim
+from scm.network_services.models.logical_routers_vrf_inner_multicast_interface_group_inner_pim_allowed_neighbors_inner import LogicalRoutersVrfInnerMulticastInterfaceGroupInnerPimAllowedNeighborsInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_msdp import LogicalRoutersVrfInnerMulticastMsdp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_msdp_peer_inner import LogicalRoutersVrfInnerMulticastMsdpPeerInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim import LogicalRoutersVrfInnerMulticastPim
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_interface_inner import LogicalRoutersVrfInnerMulticastPimInterfaceInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_rp import LogicalRoutersVrfInnerMulticastPimRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_rp_external_rp_inner import LogicalRoutersVrfInnerMulticastPimRpExternalRpInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_rp_local_rp import LogicalRoutersVrfInnerMulticastPimRpLocalRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_rp_local_rp_candidate_rp import LogicalRoutersVrfInnerMulticastPimRpLocalRpCandidateRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_rp_local_rp_static_rp import LogicalRoutersVrfInnerMulticastPimRpLocalRpStaticRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_spt_threshold_inner import LogicalRoutersVrfInnerMulticastPimSptThresholdInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_pim_ssm_address_space import LogicalRoutersVrfInnerMulticastPimSsmAddressSpace
+from scm.network_services.models.logical_routers_vrf_inner_multicast_rp import LogicalRoutersVrfInnerMulticastRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_rp_external_rp_inner import LogicalRoutersVrfInnerMulticastRpExternalRpInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_rp_local_rp import LogicalRoutersVrfInnerMulticastRpLocalRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_rp_local_rp_candidate_rp import LogicalRoutersVrfInnerMulticastRpLocalRpCandidateRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_rp_local_rp_static_rp import LogicalRoutersVrfInnerMulticastRpLocalRpStaticRp
+from scm.network_services.models.logical_routers_vrf_inner_multicast_static_route_inner import LogicalRoutersVrfInnerMulticastStaticRouteInner
+from scm.network_services.models.logical_routers_vrf_inner_multicast_static_route_inner_nexthop import LogicalRoutersVrfInnerMulticastStaticRouteInnerNexthop
+from scm.network_services.models.logical_routers_vrf_inner_ospf import LogicalRoutersVrfInnerOspf
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner import LogicalRoutersVrfInnerOspfAreaInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_interface_inner import LogicalRoutersVrfInnerOspfAreaInnerInterfaceInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_interface_inner_link_type import LogicalRoutersVrfInnerOspfAreaInnerInterfaceInnerLinkType
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_interface_inner_link_type_p2mp import LogicalRoutersVrfInnerOspfAreaInnerInterfaceInnerLinkTypeP2mp
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_interface_inner_link_type_p2mp_neighbor_inner import LogicalRoutersVrfInnerOspfAreaInnerInterfaceInnerLinkTypeP2mpNeighborInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_interface_inner_vr_timing import LogicalRoutersVrfInnerOspfAreaInnerInterfaceInnerVrTiming
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_range_inner import LogicalRoutersVrfInnerOspfAreaInnerRangeInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type import LogicalRoutersVrfInnerOspfAreaInnerType
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_normal import LogicalRoutersVrfInnerOspfAreaInnerTypeNormal
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_normal_abr import LogicalRoutersVrfInnerOspfAreaInnerTypeNormalAbr
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_nssa import LogicalRoutersVrfInnerOspfAreaInnerTypeNssa
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_nssa_abr import LogicalRoutersVrfInnerOspfAreaInnerTypeNssaAbr
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_nssa_abr_nssa_ext_range_inner import LogicalRoutersVrfInnerOspfAreaInnerTypeNssaAbrNssaExtRangeInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_nssa_default_information_originate import LogicalRoutersVrfInnerOspfAreaInnerTypeNssaDefaultInformationOriginate
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_nssa_default_route import LogicalRoutersVrfInnerOspfAreaInnerTypeNssaDefaultRoute
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_nssa_default_route_advertise import LogicalRoutersVrfInnerOspfAreaInnerTypeNssaDefaultRouteAdvertise
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_nssa_nssa_ext_range_inner import LogicalRoutersVrfInnerOspfAreaInnerTypeNssaNssaExtRangeInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_stub import LogicalRoutersVrfInnerOspfAreaInnerTypeStub
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_stub_default_route import LogicalRoutersVrfInnerOspfAreaInnerTypeStubDefaultRoute
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_type_stub_default_route_advertise import LogicalRoutersVrfInnerOspfAreaInnerTypeStubDefaultRouteAdvertise
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_virtual_link_inner import LogicalRoutersVrfInnerOspfAreaInnerVirtualLinkInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_area_inner_virtual_link_inner_vr_timing import LogicalRoutersVrfInnerOspfAreaInnerVirtualLinkInnerVrTiming
+from scm.network_services.models.logical_routers_vrf_inner_ospf_auth_profile_inner import LogicalRoutersVrfInnerOspfAuthProfileInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_auth_profile_inner_md5_inner import LogicalRoutersVrfInnerOspfAuthProfileInnerMd5Inner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_export_rules_inner import LogicalRoutersVrfInnerOspfExportRulesInner
+from scm.network_services.models.logical_routers_vrf_inner_ospf_flood_prevention import LogicalRoutersVrfInnerOspfFloodPrevention
+from scm.network_services.models.logical_routers_vrf_inner_ospf_flood_prevention_hello import LogicalRoutersVrfInnerOspfFloodPreventionHello
+from scm.network_services.models.logical_routers_vrf_inner_ospf_graceful_restart import LogicalRoutersVrfInnerOspfGracefulRestart
+from scm.network_services.models.logical_routers_vrf_inner_ospf_vr_timers import LogicalRoutersVrfInnerOspfVrTimers
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3 import LogicalRoutersVrfInnerOspfv3
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_area_inner import LogicalRoutersVrfInnerOspfv3AreaInner
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_area_inner_interface_inner import LogicalRoutersVrfInnerOspfv3AreaInnerInterfaceInner
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_area_inner_range_inner import LogicalRoutersVrfInnerOspfv3AreaInnerRangeInner
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_area_inner_type import LogicalRoutersVrfInnerOspfv3AreaInnerType
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_area_inner_type_nssa import LogicalRoutersVrfInnerOspfv3AreaInnerTypeNssa
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_area_inner_type_nssa_abr import LogicalRoutersVrfInnerOspfv3AreaInnerTypeNssaAbr
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_area_inner_type_nssa_abr_nssa_ext_range_inner import LogicalRoutersVrfInnerOspfv3AreaInnerTypeNssaAbrNssaExtRangeInner
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_auth_profile_inner import LogicalRoutersVrfInnerOspfv3AuthProfileInner
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_auth_profile_inner_ah import LogicalRoutersVrfInnerOspfv3AuthProfileInnerAh
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_auth_profile_inner_ah_md5 import LogicalRoutersVrfInnerOspfv3AuthProfileInnerAhMd5
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_auth_profile_inner_esp import LogicalRoutersVrfInnerOspfv3AuthProfileInnerEsp
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_auth_profile_inner_esp_authentication import LogicalRoutersVrfInnerOspfv3AuthProfileInnerEspAuthentication
+from scm.network_services.models.logical_routers_vrf_inner_ospfv3_auth_profile_inner_esp_encryption import LogicalRoutersVrfInnerOspfv3AuthProfileInnerEspEncryption
+from scm.network_services.models.logical_routers_vrf_inner_rib_filter import LogicalRoutersVrfInnerRibFilter
+from scm.network_services.models.logical_routers_vrf_inner_rib_filter_ipv4 import LogicalRoutersVrfInnerRibFilterIpv4
+from scm.network_services.models.logical_routers_vrf_inner_rib_filter_ipv4_bgp import LogicalRoutersVrfInnerRibFilterIpv4Bgp
+from scm.network_services.models.logical_routers_vrf_inner_rib_filter_ipv6 import LogicalRoutersVrfInnerRibFilterIpv6
+from scm.network_services.models.logical_routers_vrf_inner_rip import LogicalRoutersVrfInnerRip
+from scm.network_services.models.logical_routers_vrf_inner_rip_global_inbound_distribute_list import LogicalRoutersVrfInnerRipGlobalInboundDistributeList
+from scm.network_services.models.logical_routers_vrf_inner_rip_interface_inner import LogicalRoutersVrfInnerRipInterfaceInner
+from scm.network_services.models.logical_routers_vrf_inner_rip_interface_inner_interface_inbound_distribute_list import LogicalRoutersVrfInnerRipInterfaceInnerInterfaceInboundDistributeList
+from scm.network_services.models.logical_routers_vrf_inner_routing_table import LogicalRoutersVrfInnerRoutingTable
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ip import LogicalRoutersVrfInnerRoutingTableIp
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ip_static_route_inner import LogicalRoutersVrfInnerRoutingTableIpStaticRouteInner
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ip_static_route_inner_nexthop import LogicalRoutersVrfInnerRoutingTableIpStaticRouteInnerNexthop
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ip_static_route_inner_path_monitor import LogicalRoutersVrfInnerRoutingTableIpStaticRouteInnerPathMonitor
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ip_static_route_inner_path_monitor_monitor_destinations_inner import LogicalRoutersVrfInnerRoutingTableIpStaticRouteInnerPathMonitorMonitorDestinationsInner
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ip_static_route_inner_route_table import LogicalRoutersVrfInnerRoutingTableIpStaticRouteInnerRouteTable
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ipv6 import LogicalRoutersVrfInnerRoutingTableIpv6
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ipv6_static_route_inner import LogicalRoutersVrfInnerRoutingTableIpv6StaticRouteInner
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ipv6_static_route_inner_nexthop import LogicalRoutersVrfInnerRoutingTableIpv6StaticRouteInnerNexthop
+from scm.network_services.models.logical_routers_vrf_inner_routing_table_ipv6_static_route_inner_option import LogicalRoutersVrfInnerRoutingTableIpv6StaticRouteInnerOption
+from scm.network_services.models.logical_routers_vrf_inner_vr_admin_dists import LogicalRoutersVrfInnerVrAdminDists
+from scm.network_services.models.loopback_interfaces import LoopbackInterfaces
+from scm.network_services.models.loopback_interfaces_ip_inner import LoopbackInterfacesIpInner
+from scm.network_services.models.loopback_interfaces_ipv6 import LoopbackInterfacesIpv6
+from scm.network_services.models.loopback_interfaces_ipv6_address_inner import LoopbackInterfacesIpv6AddressInner
+from scm.network_services.models.loopback_interfaces_list_response import LoopbackInterfacesListResponse
+from scm.network_services.models.nat_rules import NatRules
+from scm.network_services.models.nat_rules_destination_translation import NatRulesDestinationTranslation
+from scm.network_services.models.nat_rules_destination_translation_dns_rewrite import NatRulesDestinationTranslationDnsRewrite
+from scm.network_services.models.nat_rules_dynamic_destination_translation import NatRulesDynamicDestinationTranslation
+from scm.network_services.models.nat_rules_list_response import NatRulesListResponse
+from scm.network_services.models.nat_rules_source_translation import NatRulesSourceTranslation
+from scm.network_services.models.nat_rules_source_translation_dynamic_ip import NatRulesSourceTranslationDynamicIp
+from scm.network_services.models.nat_rules_source_translation_dynamic_ip_and_port import NatRulesSourceTranslationDynamicIpAndPort
+from scm.network_services.models.nat_rules_source_translation_dynamic_ip_and_port_interface_address import NatRulesSourceTranslationDynamicIpAndPortInterfaceAddress
+from scm.network_services.models.nat_rules_source_translation_dynamic_ip_fallback import NatRulesSourceTranslationDynamicIpFallback
+from scm.network_services.models.nat_rules_source_translation_dynamic_ip_fallback_interface_address import NatRulesSourceTranslationDynamicIpFallbackInterfaceAddress
+from scm.network_services.models.nat_rules_source_translation_static_ip import NatRulesSourceTranslationStaticIp
+from scm.network_services.models.ospf_authentication_profiles_list_response import OSPFAuthenticationProfilesListResponse
+from scm.network_services.models.ospf_auth_profiles import OspfAuthProfiles
+from scm.network_services.models.ospf_auth_profiles_md5_inner import OspfAuthProfilesMd5Inner
+from scm.network_services.models.pbf_rules_list_response import PBFRulesListResponse
+from scm.network_services.models.pbf_rules import PbfRules
+from scm.network_services.models.pbf_rules_action import PbfRulesAction
+from scm.network_services.models.pbf_rules_action_forward import PbfRulesActionForward
+from scm.network_services.models.pbf_rules_action_forward_monitor import PbfRulesActionForwardMonitor
+from scm.network_services.models.pbf_rules_action_forward_nexthop import PbfRulesActionForwardNexthop
+from scm.network_services.models.pbf_rules_enforce_symmetric_return import PbfRulesEnforceSymmetricReturn
+from scm.network_services.models.pbf_rules_enforce_symmetric_return_nexthop_address_list_inner import PbfRulesEnforceSymmetricReturnNexthopAddressListInner
+from scm.network_services.models.pbf_rules_from import PbfRulesFrom
+from scm.network_services.models.poe import Poe
+from scm.network_services.models.qos_policy_rules_list_response import QoSPolicyRulesListResponse
+from scm.network_services.models.qos_profiles_list_response import QoSProfilesListResponse
+from scm.network_services.models.qos_policy_rules import QosPolicyRules
+from scm.network_services.models.qos_policy_rules_action import QosPolicyRulesAction
+from scm.network_services.models.qos_policy_rules_dscp_tos import QosPolicyRulesDscpTos
+from scm.network_services.models.qos_policy_rules_dscp_tos_codepoints_inner import QosPolicyRulesDscpTosCodepointsInner
+from scm.network_services.models.qos_policy_rules_dscp_tos_codepoints_inner_type import QosPolicyRulesDscpTosCodepointsInnerType
+from scm.network_services.models.qos_policy_rules_dscp_tos_codepoints_inner_type_af import QosPolicyRulesDscpTosCodepointsInnerTypeAf
+from scm.network_services.models.qos_policy_rules_dscp_tos_codepoints_inner_type_custom import QosPolicyRulesDscpTosCodepointsInnerTypeCustom
+from scm.network_services.models.qos_policy_rules_dscp_tos_codepoints_inner_type_custom_codepoint import QosPolicyRulesDscpTosCodepointsInnerTypeCustomCodepoint
+from scm.network_services.models.qos_profiles import QosProfiles
+from scm.network_services.models.qos_profiles_aggregate_bandwidth import QosProfilesAggregateBandwidth
+from scm.network_services.models.qos_profiles_class_bandwidth_type import QosProfilesClassBandwidthType
+from scm.network_services.models.qos_profiles_class_bandwidth_type_mbps import QosProfilesClassBandwidthTypeMbps
+from scm.network_services.models.qos_profiles_class_bandwidth_type_mbps_class_inner import QosProfilesClassBandwidthTypeMbpsClassInner
+from scm.network_services.models.qos_profiles_class_bandwidth_type_mbps_class_inner_class_bandwidth import QosProfilesClassBandwidthTypeMbpsClassInnerClassBandwidth
+from scm.network_services.models.qos_profiles_class_bandwidth_type_percentage import QosProfilesClassBandwidthTypePercentage
+from scm.network_services.models.qos_profiles_class_bandwidth_type_percentage_class_inner import QosProfilesClassBandwidthTypePercentageClassInner
+from scm.network_services.models.qos_profiles_class_bandwidth_type_percentage_class_inner_class_bandwidth import QosProfilesClassBandwidthTypePercentageClassInnerClassBandwidth
+from scm.network_services.models.route_access_lists import RouteAccessLists
+from scm.network_services.models.route_access_lists_list_response import RouteAccessListsListResponse
+from scm.network_services.models.route_access_lists_type import RouteAccessListsType
+from scm.network_services.models.route_access_lists_type_ipv4 import RouteAccessListsTypeIpv4
+from scm.network_services.models.route_access_lists_type_ipv4_ipv4_entry_inner import RouteAccessListsTypeIpv4Ipv4EntryInner
+from scm.network_services.models.route_access_lists_type_ipv4_ipv4_entry_inner_destination_address import RouteAccessListsTypeIpv4Ipv4EntryInnerDestinationAddress
+from scm.network_services.models.route_access_lists_type_ipv4_ipv4_entry_inner_destination_address_entry import RouteAccessListsTypeIpv4Ipv4EntryInnerDestinationAddressEntry
+from scm.network_services.models.route_access_lists_type_ipv4_ipv4_entry_inner_source_address import RouteAccessListsTypeIpv4Ipv4EntryInnerSourceAddress
+from scm.network_services.models.route_access_lists_type_ipv4_ipv4_entry_inner_source_address_entry import RouteAccessListsTypeIpv4Ipv4EntryInnerSourceAddressEntry
+from scm.network_services.models.route_community_lists import RouteCommunityLists
+from scm.network_services.models.route_community_lists_list_response import RouteCommunityListsListResponse
+from scm.network_services.models.route_community_lists_type import RouteCommunityListsType
+from scm.network_services.models.route_community_lists_type_extended import RouteCommunityListsTypeExtended
+from scm.network_services.models.route_community_lists_type_extended_extended_entry_inner import RouteCommunityListsTypeExtendedExtendedEntryInner
+from scm.network_services.models.route_community_lists_type_large import RouteCommunityListsTypeLarge
+from scm.network_services.models.route_community_lists_type_large_large_entry_inner import RouteCommunityListsTypeLargeLargeEntryInner
+from scm.network_services.models.route_community_lists_type_regular import RouteCommunityListsTypeRegular
+from scm.network_services.models.route_community_lists_type_regular_regular_entry_inner import RouteCommunityListsTypeRegularRegularEntryInner
+from scm.network_services.models.route_path_access_lists import RoutePathAccessLists
+from scm.network_services.models.route_path_access_lists_aspath_entry_inner import RoutePathAccessListsAspathEntryInner
+from scm.network_services.models.route_path_access_lists_list_response import RoutePathAccessListsListResponse
+from scm.network_services.models.route_prefix_lists import RoutePrefixLists
+from scm.network_services.models.route_prefix_lists_list_response import RoutePrefixListsListResponse
+from scm.network_services.models.route_prefix_lists_type import RoutePrefixListsType
+from scm.network_services.models.route_prefix_lists_type_ipv4 import RoutePrefixListsTypeIpv4
+from scm.network_services.models.route_prefix_lists_type_ipv4_ipv4_entry_inner import RoutePrefixListsTypeIpv4Ipv4EntryInner
+from scm.network_services.models.route_prefix_lists_type_ipv4_ipv4_entry_inner_prefix import RoutePrefixListsTypeIpv4Ipv4EntryInnerPrefix
+from scm.network_services.models.route_prefix_lists_type_ipv4_ipv4_entry_inner_prefix_entry import RoutePrefixListsTypeIpv4Ipv4EntryInnerPrefixEntry
+from scm.network_services.models.rule_based_move import RuleBasedMove
+from scm.network_services.models.sdwan_error_correction_profiles_list_response import SDWANErrorCorrectionProfilesListResponse
+from scm.network_services.models.sdwan_path_quality_profiles_list_response import SDWANPathQualityProfilesListResponse
+from scm.network_services.models.sdwan_rules_list_response import SDWANRulesListResponse
+from scm.network_services.models.sdwan_saas_quality_profiles_list_response import SDWANSaaSQualityProfilesListResponse
+from scm.network_services.models.sdwan_traffic_distribution_profiles_list_response import SDWANTrafficDistributionProfilesListResponse
+from scm.network_services.models.sdwan_error_correction_profiles import SdwanErrorCorrectionProfiles
+from scm.network_services.models.sdwan_error_correction_profiles_mode import SdwanErrorCorrectionProfilesMode
+from scm.network_services.models.sdwan_error_correction_profiles_mode_forward_error_correction import SdwanErrorCorrectionProfilesModeForwardErrorCorrection
+from scm.network_services.models.sdwan_error_correction_profiles_mode_packet_duplication import SdwanErrorCorrectionProfilesModePacketDuplication
+from scm.network_services.models.sdwan_path_quality_profiles import SdwanPathQualityProfiles
+from scm.network_services.models.sdwan_path_quality_profiles_metric import SdwanPathQualityProfilesMetric
+from scm.network_services.models.sdwan_path_quality_profiles_metric_jitter import SdwanPathQualityProfilesMetricJitter
+from scm.network_services.models.sdwan_path_quality_profiles_metric_latency import SdwanPathQualityProfilesMetricLatency
+from scm.network_services.models.sdwan_path_quality_profiles_metric_pkt_loss import SdwanPathQualityProfilesMetricPktLoss
+from scm.network_services.models.sdwan_rules import SdwanRules
+from scm.network_services.models.sdwan_rules_action import SdwanRulesAction
+from scm.network_services.models.sdwan_saas_quality_profiles import SdwanSaasQualityProfiles
+from scm.network_services.models.sdwan_saas_quality_profiles_monitor_mode import SdwanSaasQualityProfilesMonitorMode
+from scm.network_services.models.sdwan_saas_quality_profiles_monitor_mode_http_https import SdwanSaasQualityProfilesMonitorModeHttpHttps
+from scm.network_services.models.sdwan_saas_quality_profiles_monitor_mode_static_ip import SdwanSaasQualityProfilesMonitorModeStaticIp
+from scm.network_services.models.sdwan_saas_quality_profiles_monitor_mode_static_ip_fqdn import SdwanSaasQualityProfilesMonitorModeStaticIpFqdn
+from scm.network_services.models.sdwan_saas_quality_profiles_monitor_mode_static_ip_ip_address_inner import SdwanSaasQualityProfilesMonitorModeStaticIpIpAddressInner
+from scm.network_services.models.sdwan_traffic_distribution_profiles import SdwanTrafficDistributionProfiles
+from scm.network_services.models.sdwan_traffic_distribution_profiles_link_tags_inner import SdwanTrafficDistributionProfilesLinkTagsInner
+from scm.network_services.models.system_match_list import SystemMatchList
+from scm.network_services.models.system_match_list_list_response import SystemMatchListListResponse
+from scm.network_services.models.tunnel_interfaces import TunnelInterfaces
+from scm.network_services.models.tunnel_interfaces_ip_inner import TunnelInterfacesIpInner
+from scm.network_services.models.tunnel_interfaces_ipv6 import TunnelInterfacesIpv6
+from scm.network_services.models.tunnel_interfaces_ipv6_address_inner import TunnelInterfacesIpv6AddressInner
+from scm.network_services.models.tunnel_interfaces_list_response import TunnelInterfacesListResponse
+from scm.network_services.models.userid_match_list import UseridMatchList
+from scm.network_services.models.userid_match_list_list_response import UseridMatchListListResponse
+from scm.network_services.models.vlan_interfaces_list_response import VLANInterfacesListResponse
+from scm.network_services.models.vlan_interfaces import VlanInterfaces
+from scm.network_services.models.vlan_interfaces_arp_inner import VlanInterfacesArpInner
+from scm.network_services.models.vlan_interfaces_ddns_config import VlanInterfacesDdnsConfig
+from scm.network_services.models.vlan_interfaces_dhcp_client import VlanInterfacesDhcpClient
+from scm.network_services.models.vlan_interfaces_dhcp_client_send_hostname import VlanInterfacesDhcpClientSendHostname
+from scm.network_services.models.vlan_interfaces_ip_inner import VlanInterfacesIpInner
+from scm.network_services.models.zone_protection_profiles import ZoneProtectionProfiles
+from scm.network_services.models.zone_protection_profiles_flood import ZoneProtectionProfilesFlood
+from scm.network_services.models.zone_protection_profiles_flood_icmp import ZoneProtectionProfilesFloodIcmp
+from scm.network_services.models.zone_protection_profiles_flood_icmp_red import ZoneProtectionProfilesFloodIcmpRed
+from scm.network_services.models.zone_protection_profiles_flood_icmpv6 import ZoneProtectionProfilesFloodIcmpv6
+from scm.network_services.models.zone_protection_profiles_flood_icmpv6_red import ZoneProtectionProfilesFloodIcmpv6Red
+from scm.network_services.models.zone_protection_profiles_flood_other_ip import ZoneProtectionProfilesFloodOtherIp
+from scm.network_services.models.zone_protection_profiles_flood_other_ip_red import ZoneProtectionProfilesFloodOtherIpRed
+from scm.network_services.models.zone_protection_profiles_flood_sctp_init import ZoneProtectionProfilesFloodSctpInit
+from scm.network_services.models.zone_protection_profiles_flood_sctp_init_red import ZoneProtectionProfilesFloodSctpInitRed
+from scm.network_services.models.zone_protection_profiles_flood_tcp_syn import ZoneProtectionProfilesFloodTcpSyn
+from scm.network_services.models.zone_protection_profiles_flood_tcp_syn_red import ZoneProtectionProfilesFloodTcpSynRed
+from scm.network_services.models.zone_protection_profiles_flood_tcp_syn_syn_cookies import ZoneProtectionProfilesFloodTcpSynSynCookies
+from scm.network_services.models.zone_protection_profiles_flood_udp import ZoneProtectionProfilesFloodUdp
+from scm.network_services.models.zone_protection_profiles_flood_udp_red import ZoneProtectionProfilesFloodUdpRed
+from scm.network_services.models.zone_protection_profiles_ipv6 import ZoneProtectionProfilesIpv6
+from scm.network_services.models.zone_protection_profiles_ipv6_filter_ext_hdr import ZoneProtectionProfilesIpv6FilterExtHdr
+from scm.network_services.models.zone_protection_profiles_ipv6_ignore_inv_pkt import ZoneProtectionProfilesIpv6IgnoreInvPkt
+from scm.network_services.models.zone_protection_profiles_l2_sec_group_tag_protection import ZoneProtectionProfilesL2SecGroupTagProtection
+from scm.network_services.models.zone_protection_profiles_l2_sec_group_tag_protection_tags_inner import ZoneProtectionProfilesL2SecGroupTagProtectionTagsInner
+from scm.network_services.models.zone_protection_profiles_list_response import ZoneProtectionProfilesListResponse
+from scm.network_services.models.zone_protection_profiles_non_ip_protocol import ZoneProtectionProfilesNonIpProtocol
+from scm.network_services.models.zone_protection_profiles_non_ip_protocol_protocol_inner import ZoneProtectionProfilesNonIpProtocolProtocolInner
+from scm.network_services.models.zone_protection_profiles_scan_inner import ZoneProtectionProfilesScanInner
+from scm.network_services.models.zone_protection_profiles_scan_inner_action import ZoneProtectionProfilesScanInnerAction
+from scm.network_services.models.zone_protection_profiles_scan_inner_action_block_ip import ZoneProtectionProfilesScanInnerActionBlockIp
+from scm.network_services.models.zone_protection_profiles_scan_white_list_inner import ZoneProtectionProfilesScanWhiteListInner
+from scm.network_services.models.zones import Zones
+from scm.network_services.models.zones_device_acl import ZonesDeviceAcl
+from scm.network_services.models.zones_list_response import ZonesListResponse
+from scm.network_services.models.zones_network import ZonesNetwork
diff --git a/scm/network_services/api/__init__.py b/scm/network_services/api/__init__.py
new file mode 100644
index 00000000..33d44b7d
--- /dev/null
+++ b/scm/network_services/api/__init__.py
@@ -0,0 +1,54 @@
+# flake8: noqa
+
+# import apis into api package
+from scm.network_services.api.aggregate_interfaces_api import AggregateInterfacesApi
+from scm.network_services.api.auto_vpn_clusters_api import AutoVPNClustersApi
+from scm.network_services.api.auto_vpn_config_push_api import AutoVPNConfigPushApi
+from scm.network_services.api.auto_vpn_monitor_api import AutoVPNMonitorApi
+from scm.network_services.api.auto_vpn_settings_api import AutoVPNSettingsApi
+from scm.network_services.api.bgp_address_family_profiles_api import BGPAddressFamilyProfilesApi
+from scm.network_services.api.bgp_authentication_profiles_api import BGPAuthenticationProfilesApi
+from scm.network_services.api.bgp_filtering_profiles_api import BGPFilteringProfilesApi
+from scm.network_services.api.bgp_redistribution_profiles_api import BGPRedistributionProfilesApi
+from scm.network_services.api.bgp_route_map_redistributions_api import BGPRouteMapRedistributionsApi
+from scm.network_services.api.bgp_route_maps_api import BGPRouteMapsApi
+from scm.network_services.api.config_match_list_api import ConfigMatchListApi
+from scm.network_services.api.dhcp_interfaces_api import DHCPInterfacesApi
+from scm.network_services.api.dns_proxies_api import DNSProxiesApi
+from scm.network_services.api.ethernet_interfaces_api import EthernetInterfacesApi
+from scm.network_services.api.globalprotect_match_list_api import GlobalprotectMatchListApi
+from scm.network_services.api.hipmatch_match_list_api import HipmatchMatchListApi
+from scm.network_services.api.ike_crypto_profiles_api import IKECryptoProfilesApi
+from scm.network_services.api.ike_gateways_api import IKEGatewaysApi
+from scm.network_services.api.ipsec_crypto_profiles_api import IPsecCryptoProfilesApi
+from scm.network_services.api.ipsec_tunnels_api import IPsecTunnelsApi
+from scm.network_services.api.interface_management_profiles_api import InterfaceManagementProfilesApi
+from scm.network_services.api.iptag_match_list_api import IptagMatchListApi
+from scm.network_services.api.lldp_profiles_api import LLDPProfilesApi
+from scm.network_services.api.layer2_subinterfaces_api import Layer2SubinterfacesApi
+from scm.network_services.api.layer3_subinterfaces_api import Layer3SubinterfacesApi
+from scm.network_services.api.link_tags_api import LinkTagsApi
+from scm.network_services.api.logical_routers_api import LogicalRoutersApi
+from scm.network_services.api.loopback_interfaces_api import LoopbackInterfacesApi
+from scm.network_services.api.nat_rules_api import NATRulesApi
+from scm.network_services.api.ospf_authentication_profiles_api import OSPFAuthenticationProfilesApi
+from scm.network_services.api.pbf_rules_api import PBFRulesApi
+from scm.network_services.api.qos_profiles_api import QoSProfilesApi
+from scm.network_services.api.qos_rules_api import QoSRulesApi
+from scm.network_services.api.remote_networks_license_api import RemoteNetworksLicenseApi
+from scm.network_services.api.route_access_lists_api import RouteAccessListsApi
+from scm.network_services.api.route_community_lists_api import RouteCommunityListsApi
+from scm.network_services.api.route_path_access_lists_api import RoutePathAccessListsApi
+from scm.network_services.api.route_prefix_lists_api import RoutePrefixListsApi
+from scm.network_services.api.sdwan_error_correction_profiles_api import SDWANErrorCorrectionProfilesApi
+from scm.network_services.api.sdwan_path_quality_profiles_api import SDWANPathQualityProfilesApi
+from scm.network_services.api.sdwan_rules_api import SDWANRulesApi
+from scm.network_services.api.sdwan_saas_quality_profiles_api import SDWANSaaSQualityProfilesApi
+from scm.network_services.api.sdwan_traffic_distribution_profiles_api import SDWANTrafficDistributionProfilesApi
+from scm.network_services.api.security_zones_api import SecurityZonesApi
+from scm.network_services.api.system_match_list_api import SystemMatchListApi
+from scm.network_services.api.tunnel_interfaces_api import TunnelInterfacesApi
+from scm.network_services.api.userid_match_list_api import UseridMatchListApi
+from scm.network_services.api.vlan_interfaces_api import VLANInterfacesApi
+from scm.network_services.api.zone_protection_profiles_api import ZoneProtectionProfilesApi
+
diff --git a/scm/network_services/api/aggregate_interfaces_api.py b/scm/network_services/api/aggregate_interfaces_api.py
new file mode 100644
index 00000000..823a24d8
--- /dev/null
+++ b/scm/network_services/api/aggregate_interfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.aggregate_interfaces import AggregateInterfaces
+from scm.network_services.models.aggregate_interfaces_list_response import AggregateInterfacesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AggregateInterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_aggregate_interfaces(
+ self,
+ aggregate_interfaces: Annotated[Optional[AggregateInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AggregateInterfaces:
+ """Create an Aggregate Interface
+
+ Create a new Aggregate Interface.
+
+ :param aggregate_interfaces: Created
+ :type aggregate_interfaces: AggregateInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_aggregate_interfaces_serialize(
+ aggregate_interfaces=aggregate_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_aggregate_interfaces_with_http_info(
+ self,
+ aggregate_interfaces: Annotated[Optional[AggregateInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AggregateInterfaces]:
+ """Create an Aggregate Interface
+
+ Create a new Aggregate Interface.
+
+ :param aggregate_interfaces: Created
+ :type aggregate_interfaces: AggregateInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_aggregate_interfaces_serialize(
+ aggregate_interfaces=aggregate_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_aggregate_interfaces_without_preload_content(
+ self,
+ aggregate_interfaces: Annotated[Optional[AggregateInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an Aggregate Interface
+
+ Create a new Aggregate Interface.
+
+ :param aggregate_interfaces: Created
+ :type aggregate_interfaces: AggregateInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_aggregate_interfaces_serialize(
+ aggregate_interfaces=aggregate_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_aggregate_interfaces_serialize(
+ self,
+ aggregate_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if aggregate_interfaces is not None:
+ _body_params = aggregate_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/aggregate-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_aggregate_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an Aggregate Interface
+
+ Delete an Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_aggregate_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_aggregate_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an Aggregate Interface
+
+ Delete an Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_aggregate_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_aggregate_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an Aggregate Interface
+
+ Delete an Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_aggregate_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_aggregate_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/aggregate-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_aggregate_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AggregateInterfaces:
+ """Get an Aggregate Interface
+
+ Get an existing Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_aggregate_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_aggregate_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AggregateInterfaces]:
+ """Get an Aggregate Interface
+
+ Get an existing Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_aggregate_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_aggregate_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an Aggregate Interface
+
+ Get an existing Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_aggregate_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_aggregate_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/aggregate-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_aggregate_interfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AggregateInterfacesListResponse:
+ """List Aggregate Interfaces
+
+ Retrieve a list of Aggregate Interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_aggregate_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_aggregate_interfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AggregateInterfacesListResponse]:
+ """List Aggregate Interfaces
+
+ Retrieve a list of Aggregate Interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_aggregate_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_aggregate_interfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List Aggregate Interfaces
+
+ Retrieve a list of Aggregate Interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_aggregate_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_aggregate_interfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/aggregate-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_aggregate_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ aggregate_interfaces: Annotated[Optional[AggregateInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AggregateInterfaces:
+ """Update an Aggregate Interface
+
+ Update an existing Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param aggregate_interfaces: OK
+ :type aggregate_interfaces: AggregateInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_aggregate_interfaces_by_id_serialize(
+ id=id,
+ aggregate_interfaces=aggregate_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_aggregate_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ aggregate_interfaces: Annotated[Optional[AggregateInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AggregateInterfaces]:
+ """Update an Aggregate Interface
+
+ Update an existing Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param aggregate_interfaces: OK
+ :type aggregate_interfaces: AggregateInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_aggregate_interfaces_by_id_serialize(
+ id=id,
+ aggregate_interfaces=aggregate_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_aggregate_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ aggregate_interfaces: Annotated[Optional[AggregateInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an Aggregate Interface
+
+ Update an existing Aggregate Interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param aggregate_interfaces: OK
+ :type aggregate_interfaces: AggregateInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_aggregate_interfaces_by_id_serialize(
+ id=id,
+ aggregate_interfaces=aggregate_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AggregateInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_aggregate_interfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single aggregate_interfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_aggregate_interfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_aggregate_interfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_aggregate_interfaces_by_id_serialize(
+ self,
+ id,
+ aggregate_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if aggregate_interfaces is not None:
+ _body_params = aggregate_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/aggregate-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/auto_vpn_clusters_api.py b/scm/network_services/api/auto_vpn_clusters_api.py
new file mode 100644
index 00000000..90385e1e
--- /dev/null
+++ b/scm/network_services/api/auto_vpn_clusters_api.py
@@ -0,0 +1,1556 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.auto_vpn_clusters_list_response import AutoVPNClustersListResponse
+from scm.network_services.models.auto_vpn_clusters import AutoVpnClusters
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AutoVPNClustersApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_auto_vpn_clusters(
+ self,
+ auto_vpn_clusters: Annotated[Optional[AutoVpnClusters], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AutoVpnClusters:
+ """Create an Auto VPN cluster
+
+ Create a new Auto VPN cluster.
+
+ :param auto_vpn_clusters: Created
+ :type auto_vpn_clusters: AutoVpnClusters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_auto_vpn_clusters_serialize(
+ auto_vpn_clusters=auto_vpn_clusters,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_auto_vpn_clusters_with_http_info(
+ self,
+ auto_vpn_clusters: Annotated[Optional[AutoVpnClusters], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AutoVpnClusters]:
+ """Create an Auto VPN cluster
+
+ Create a new Auto VPN cluster.
+
+ :param auto_vpn_clusters: Created
+ :type auto_vpn_clusters: AutoVpnClusters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_auto_vpn_clusters_serialize(
+ auto_vpn_clusters=auto_vpn_clusters,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_auto_vpn_clusters_without_preload_content(
+ self,
+ auto_vpn_clusters: Annotated[Optional[AutoVpnClusters], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an Auto VPN cluster
+
+ Create a new Auto VPN cluster.
+
+ :param auto_vpn_clusters: Created
+ :type auto_vpn_clusters: AutoVpnClusters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_auto_vpn_clusters_serialize(
+ auto_vpn_clusters=auto_vpn_clusters,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_auto_vpn_clusters_serialize(
+ self,
+ auto_vpn_clusters,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if auto_vpn_clusters is not None:
+ _body_params = auto_vpn_clusters
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/auto-vpn-clusters',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_auto_vpn_clusters_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an Auto VPN cluster
+
+ Delete an Auto VPN cluster.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_auto_vpn_clusters_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an Auto VPN cluster
+
+ Delete an Auto VPN cluster.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_auto_vpn_clusters_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an Auto VPN cluster
+
+ Delete an Auto VPN cluster.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_auto_vpn_clusters_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/auto-vpn-clusters/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_clusters_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AutoVpnClusters:
+ """Get an Auto VPN cluster
+
+ Get an existing Auto VPN clusters.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_clusters_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AutoVpnClusters]:
+ """Get an Auto VPN cluster
+
+ Get an existing Auto VPN clusters.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_clusters_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an Auto VPN cluster
+
+ Get an existing Auto VPN clusters.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_auto_vpn_clusters_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/auto-vpn-clusters/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_auto_vpn_clusters(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AutoVPNClustersListResponse:
+ """List Auto VPN clusters
+
+ Retrieve a list of Auto VPN clusters.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_auto_vpn_clusters_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVPNClustersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_auto_vpn_clusters_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AutoVPNClustersListResponse]:
+ """List Auto VPN clusters
+
+ Retrieve a list of Auto VPN clusters.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_auto_vpn_clusters_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVPNClustersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_auto_vpn_clusters_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List Auto VPN clusters
+
+ Retrieve a list of Auto VPN clusters.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_auto_vpn_clusters_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVPNClustersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_auto_vpn_clusters_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/auto-vpn-clusters',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_auto_vpn_clusters_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ auto_vpn_clusters: Annotated[Optional[AutoVpnClusters], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AutoVpnClusters:
+ """Update an Auto VPN cluster
+
+ Update an existing Auto VPN cluster.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param auto_vpn_clusters: OK
+ :type auto_vpn_clusters: AutoVpnClusters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ auto_vpn_clusters=auto_vpn_clusters,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_auto_vpn_clusters_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ auto_vpn_clusters: Annotated[Optional[AutoVpnClusters], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AutoVpnClusters]:
+ """Update an Auto VPN cluster
+
+ Update an existing Auto VPN cluster.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param auto_vpn_clusters: OK
+ :type auto_vpn_clusters: AutoVpnClusters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ auto_vpn_clusters=auto_vpn_clusters,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_auto_vpn_clusters_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ auto_vpn_clusters: Annotated[Optional[AutoVpnClusters], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an Auto VPN cluster
+
+ Update an existing Auto VPN cluster.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param auto_vpn_clusters: OK
+ :type auto_vpn_clusters: AutoVpnClusters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_auto_vpn_clusters_by_id_serialize(
+ id=id,
+ auto_vpn_clusters=auto_vpn_clusters,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnClusters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_auto_vpn_clusters(
+ self,
+ name: str,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single auto_vpn_clusters object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name.
+
+ Args:
+ name: The name of the object to fetch
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_auto_vpn_clusters(name="my-object")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_auto_vpn_clusters(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_auto_vpn_clusters_by_id_serialize(
+ self,
+ id,
+ auto_vpn_clusters,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if auto_vpn_clusters is not None:
+ _body_params = auto_vpn_clusters
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/auto-vpn-clusters/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/auto_vpn_config_push_api.py b/scm/network_services/api/auto_vpn_config_push_api.py
new file mode 100644
index 00000000..a199cd51
--- /dev/null
+++ b/scm/network_services/api/auto_vpn_config_push_api.py
@@ -0,0 +1,332 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.auto_vpn_push_config import AutoVpnPushConfig
+from scm.network_services.models.auto_vpn_push_response import AutoVpnPushResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AutoVPNConfigPushApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_auto_vpn_push_configs(
+ self,
+ auto_vpn_push_config: Annotated[Optional[AutoVpnPushConfig], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AutoVpnPushResponse:
+ """Push Auto VPN configs
+
+ Push Auto VPN configs.
+
+ :param auto_vpn_push_config: Created
+ :type auto_vpn_push_config: AutoVpnPushConfig
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_auto_vpn_push_configs_serialize(
+ auto_vpn_push_config=auto_vpn_push_config,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AutoVpnPushResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_auto_vpn_push_configs_with_http_info(
+ self,
+ auto_vpn_push_config: Annotated[Optional[AutoVpnPushConfig], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AutoVpnPushResponse]:
+ """Push Auto VPN configs
+
+ Push Auto VPN configs.
+
+ :param auto_vpn_push_config: Created
+ :type auto_vpn_push_config: AutoVpnPushConfig
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_auto_vpn_push_configs_serialize(
+ auto_vpn_push_config=auto_vpn_push_config,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AutoVpnPushResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_auto_vpn_push_configs_without_preload_content(
+ self,
+ auto_vpn_push_config: Annotated[Optional[AutoVpnPushConfig], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Push Auto VPN configs
+
+ Push Auto VPN configs.
+
+ :param auto_vpn_push_config: Created
+ :type auto_vpn_push_config: AutoVpnPushConfig
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_auto_vpn_push_configs_serialize(
+ auto_vpn_push_config=auto_vpn_push_config,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "AutoVpnPushResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_auto_vpn_push_configs_serialize(
+ self,
+ auto_vpn_push_config,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if auto_vpn_push_config is not None:
+ _body_params = auto_vpn_push_config
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/auto-vpn-push',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/auto_vpn_monitor_api.py b/scm/network_services/api/auto_vpn_monitor_api.py
new file mode 100644
index 00000000..e5831a7d
--- /dev/null
+++ b/scm/network_services/api/auto_vpn_monitor_api.py
@@ -0,0 +1,300 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from scm.network_services.models.get_auto_vpn_monitor200_response import GetAutoVPNMonitor200Response
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AutoVPNMonitorApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_monitor(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GetAutoVPNMonitor200Response:
+ """Get Auto VPN status
+
+ Get the status of the Auto VPN clusters.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_monitor_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GetAutoVPNMonitor200Response",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_monitor_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GetAutoVPNMonitor200Response]:
+ """Get Auto VPN status
+
+ Get the status of the Auto VPN clusters.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_monitor_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GetAutoVPNMonitor200Response",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_monitor_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get Auto VPN status
+
+ Get the status of the Auto VPN clusters.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_monitor_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GetAutoVPNMonitor200Response",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_auto_vpn_monitor_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/auto-vpn-monitor',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/auto_vpn_settings_api.py b/scm/network_services/api/auto_vpn_settings_api.py
new file mode 100644
index 00000000..3cdf0888
--- /dev/null
+++ b/scm/network_services/api/auto_vpn_settings_api.py
@@ -0,0 +1,595 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.auto_vpn_settings import AutoVpnSettings
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class AutoVPNSettingsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_settings(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AutoVpnSettings:
+ """Get Auto VPN settings
+
+ Retrieve the Auto VPN settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_settings_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_settings_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AutoVpnSettings]:
+ """Get Auto VPN settings
+
+ Retrieve the Auto VPN settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_settings_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_auto_vpn_settings_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get Auto VPN settings
+
+ Retrieve the Auto VPN settings.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_auto_vpn_settings_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_auto_vpn_settings_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/auto-vpn-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_auto_vpn_settings(
+ self,
+ auto_vpn_settings: Annotated[Optional[AutoVpnSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> AutoVpnSettings:
+ """Update Auto VPN settings
+
+ Update Auto VPN settings.
+
+ :param auto_vpn_settings: OK
+ :type auto_vpn_settings: AutoVpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_auto_vpn_settings_serialize(
+ auto_vpn_settings=auto_vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_auto_vpn_settings_with_http_info(
+ self,
+ auto_vpn_settings: Annotated[Optional[AutoVpnSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[AutoVpnSettings]:
+ """Update Auto VPN settings
+
+ Update Auto VPN settings.
+
+ :param auto_vpn_settings: OK
+ :type auto_vpn_settings: AutoVpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_auto_vpn_settings_serialize(
+ auto_vpn_settings=auto_vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_auto_vpn_settings_without_preload_content(
+ self,
+ auto_vpn_settings: Annotated[Optional[AutoVpnSettings], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update Auto VPN settings
+
+ Update Auto VPN settings.
+
+ :param auto_vpn_settings: OK
+ :type auto_vpn_settings: AutoVpnSettings
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_auto_vpn_settings_serialize(
+ auto_vpn_settings=auto_vpn_settings,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "AutoVpnSettings",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _update_auto_vpn_settings_serialize(
+ self,
+ auto_vpn_settings,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if auto_vpn_settings is not None:
+ _body_params = auto_vpn_settings
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/auto-vpn-settings',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/bgp_address_family_profiles_api.py b/scm/network_services/api/bgp_address_family_profiles_api.py
new file mode 100644
index 00000000..8c75682d
--- /dev/null
+++ b/scm/network_services/api/bgp_address_family_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.bgp_address_family_profiles_list_response import BGPAddressFamilyProfilesListResponse
+from scm.network_services.models.bgp_address_family_profiles import BgpAddressFamilyProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BGPAddressFamilyProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_address_family_profiles(
+ self,
+ bgp_address_family_profiles: Annotated[Optional[BgpAddressFamilyProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpAddressFamilyProfiles:
+ """Create a BGP address family profile
+
+ Create a new BGP address family profile.
+
+ :param bgp_address_family_profiles: Created
+ :type bgp_address_family_profiles: BgpAddressFamilyProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_address_family_profiles_serialize(
+ bgp_address_family_profiles=bgp_address_family_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_address_family_profiles_with_http_info(
+ self,
+ bgp_address_family_profiles: Annotated[Optional[BgpAddressFamilyProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpAddressFamilyProfiles]:
+ """Create a BGP address family profile
+
+ Create a new BGP address family profile.
+
+ :param bgp_address_family_profiles: Created
+ :type bgp_address_family_profiles: BgpAddressFamilyProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_address_family_profiles_serialize(
+ bgp_address_family_profiles=bgp_address_family_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_address_family_profiles_without_preload_content(
+ self,
+ bgp_address_family_profiles: Annotated[Optional[BgpAddressFamilyProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a BGP address family profile
+
+ Create a new BGP address family profile.
+
+ :param bgp_address_family_profiles: Created
+ :type bgp_address_family_profiles: BgpAddressFamilyProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_address_family_profiles_serialize(
+ bgp_address_family_profiles=bgp_address_family_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_bgp_address_family_profiles_serialize(
+ self,
+ bgp_address_family_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_address_family_profiles is not None:
+ _body_params = bgp_address_family_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/bgp-address-family-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_address_family_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a BGP address family profile
+
+ Delete a BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_address_family_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a BGP address family profile
+
+ Delete a BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_address_family_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a BGP address family profile
+
+ Delete a BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_bgp_address_family_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/bgp-address-family-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_address_family_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpAddressFamilyProfiles:
+ """Get a BGP address family profile
+
+ Get an existing BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_address_family_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpAddressFamilyProfiles]:
+ """Get a BGP address family profile
+
+ Get an existing BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_address_family_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a BGP address family profile
+
+ Get an existing BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_bgp_address_family_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-address-family-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_address_family_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BGPAddressFamilyProfilesListResponse:
+ """List BGP address family profiles
+
+ Retrieve a list of BGP address family profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_address_family_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPAddressFamilyProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_address_family_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BGPAddressFamilyProfilesListResponse]:
+ """List BGP address family profiles
+
+ Retrieve a list of BGP address family profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_address_family_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPAddressFamilyProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_address_family_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List BGP address family profiles
+
+ Retrieve a list of BGP address family profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_address_family_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPAddressFamilyProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_bgp_address_family_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-address-family-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_address_family_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_address_family_profiles: Annotated[Optional[BgpAddressFamilyProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpAddressFamilyProfiles:
+ """Update a BGP address family profile
+
+ Update an existing BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_address_family_profiles: OK
+ :type bgp_address_family_profiles: BgpAddressFamilyProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ bgp_address_family_profiles=bgp_address_family_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_address_family_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_address_family_profiles: Annotated[Optional[BgpAddressFamilyProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpAddressFamilyProfiles]:
+ """Update a BGP address family profile
+
+ Update an existing BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_address_family_profiles: OK
+ :type bgp_address_family_profiles: BgpAddressFamilyProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ bgp_address_family_profiles=bgp_address_family_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_address_family_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_address_family_profiles: Annotated[Optional[BgpAddressFamilyProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a BGP address family profile
+
+ Update an existing BGP address family profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_address_family_profiles: OK
+ :type bgp_address_family_profiles: BgpAddressFamilyProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_address_family_profiles_by_id_serialize(
+ id=id,
+ bgp_address_family_profiles=bgp_address_family_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAddressFamilyProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_bgp_address_family_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single bgp_address_family_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_bgp_address_family_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_bgp_address_family_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_bgp_address_family_profiles_by_id_serialize(
+ self,
+ id,
+ bgp_address_family_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_address_family_profiles is not None:
+ _body_params = bgp_address_family_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bgp-address-family-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/bgp_authentication_profiles_api.py b/scm/network_services/api/bgp_authentication_profiles_api.py
new file mode 100644
index 00000000..0ba29b92
--- /dev/null
+++ b/scm/network_services/api/bgp_authentication_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.bgp_authentication_profiles_list_response import BGPAuthenticationProfilesListResponse
+from scm.network_services.models.bgp_auth_profiles import BgpAuthProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BGPAuthenticationProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_authentication_profiles(
+ self,
+ bgp_auth_profiles: Annotated[Optional[BgpAuthProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpAuthProfiles:
+ """Create a BGP authentication profile
+
+ Create a new BGP authentication profile.
+
+ :param bgp_auth_profiles: Created
+ :type bgp_auth_profiles: BgpAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_authentication_profiles_serialize(
+ bgp_auth_profiles=bgp_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_authentication_profiles_with_http_info(
+ self,
+ bgp_auth_profiles: Annotated[Optional[BgpAuthProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpAuthProfiles]:
+ """Create a BGP authentication profile
+
+ Create a new BGP authentication profile.
+
+ :param bgp_auth_profiles: Created
+ :type bgp_auth_profiles: BgpAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_authentication_profiles_serialize(
+ bgp_auth_profiles=bgp_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_authentication_profiles_without_preload_content(
+ self,
+ bgp_auth_profiles: Annotated[Optional[BgpAuthProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a BGP authentication profile
+
+ Create a new BGP authentication profile.
+
+ :param bgp_auth_profiles: Created
+ :type bgp_auth_profiles: BgpAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_authentication_profiles_serialize(
+ bgp_auth_profiles=bgp_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_bgp_authentication_profiles_serialize(
+ self,
+ bgp_auth_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_auth_profiles is not None:
+ _body_params = bgp_auth_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/bgp-auth-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a BGP authentication profile
+
+ Delete a BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a BGP authentication profile
+
+ Delete a BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a BGP authentication profile
+
+ Delete a BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_bgp_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/bgp-auth-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpAuthProfiles:
+ """Get a BGP authentication profile
+
+ Get an existing BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpAuthProfiles]:
+ """Get a BGP authentication profile
+
+ Get an existing BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a BGP authentication profile
+
+ Get an existing BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_bgp_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-auth-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_authentication_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BGPAuthenticationProfilesListResponse:
+ """List BGP authentication profiles
+
+ Retrieve a list of BGP authentication profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_authentication_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPAuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_authentication_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BGPAuthenticationProfilesListResponse]:
+ """List BGP authentication profiles
+
+ Retrieve a list of BGP authentication profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_authentication_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPAuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_authentication_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List BGP authentication profiles
+
+ Retrieve a list of BGP authentication profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_authentication_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPAuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_bgp_authentication_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-auth-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_auth_profiles: Annotated[Optional[BgpAuthProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpAuthProfiles:
+ """Update a BGP authentication profile
+
+ Update an existing BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_auth_profiles: OK
+ :type bgp_auth_profiles: BgpAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ bgp_auth_profiles=bgp_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_auth_profiles: Annotated[Optional[BgpAuthProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpAuthProfiles]:
+ """Update a BGP authentication profile
+
+ Update an existing BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_auth_profiles: OK
+ :type bgp_auth_profiles: BgpAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ bgp_auth_profiles=bgp_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_auth_profiles: Annotated[Optional[BgpAuthProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a BGP authentication profile
+
+ Update an existing BGP authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_auth_profiles: OK
+ :type bgp_auth_profiles: BgpAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_authentication_profiles_by_id_serialize(
+ id=id,
+ bgp_auth_profiles=bgp_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_bgp_authentication_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single bgp_authentication_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_bgp_authentication_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_bgp_authentication_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_bgp_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ bgp_auth_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_auth_profiles is not None:
+ _body_params = bgp_auth_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bgp-auth-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/bgp_filtering_profiles_api.py b/scm/network_services/api/bgp_filtering_profiles_api.py
new file mode 100644
index 00000000..620889c8
--- /dev/null
+++ b/scm/network_services/api/bgp_filtering_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.bgp_filtering_profiles_list_response import BGPFilteringProfilesListResponse
+from scm.network_services.models.bgp_filtering_profiles import BgpFilteringProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BGPFilteringProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_filtering_profiles(
+ self,
+ bgp_filtering_profiles: Annotated[Optional[BgpFilteringProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpFilteringProfiles:
+ """Create a BGP filtering profile
+
+ Create a new BGP filtering profile.
+
+ :param bgp_filtering_profiles: Created
+ :type bgp_filtering_profiles: BgpFilteringProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_filtering_profiles_serialize(
+ bgp_filtering_profiles=bgp_filtering_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_filtering_profiles_with_http_info(
+ self,
+ bgp_filtering_profiles: Annotated[Optional[BgpFilteringProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpFilteringProfiles]:
+ """Create a BGP filtering profile
+
+ Create a new BGP filtering profile.
+
+ :param bgp_filtering_profiles: Created
+ :type bgp_filtering_profiles: BgpFilteringProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_filtering_profiles_serialize(
+ bgp_filtering_profiles=bgp_filtering_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_filtering_profiles_without_preload_content(
+ self,
+ bgp_filtering_profiles: Annotated[Optional[BgpFilteringProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a BGP filtering profile
+
+ Create a new BGP filtering profile.
+
+ :param bgp_filtering_profiles: Created
+ :type bgp_filtering_profiles: BgpFilteringProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_filtering_profiles_serialize(
+ bgp_filtering_profiles=bgp_filtering_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_bgp_filtering_profiles_serialize(
+ self,
+ bgp_filtering_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_filtering_profiles is not None:
+ _body_params = bgp_filtering_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/bgp-filtering-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_filtering_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a BGP filtering profile
+
+ Delete a BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_filtering_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a BGP filtering profile
+
+ Delete a BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_filtering_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a BGP filtering profile
+
+ Delete a BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_bgp_filtering_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/bgp-filtering-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_filtering_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpFilteringProfiles:
+ """Get a BGP filtering profile
+
+ Get an existing BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_filtering_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpFilteringProfiles]:
+ """Get a BGP filtering profile
+
+ Get an existing BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_filtering_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a BGP filtering profile
+
+ Get an existing BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_bgp_filtering_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-filtering-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_filtering_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BGPFilteringProfilesListResponse:
+ """List BGP filtering profiles
+
+ Retrieve a list of BGP filtering profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_filtering_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPFilteringProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_filtering_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BGPFilteringProfilesListResponse]:
+ """List BGP filtering profiles
+
+ Retrieve a list of BGP filtering profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_filtering_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPFilteringProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_filtering_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List BGP filtering profiles
+
+ Retrieve a list of BGP filtering profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_filtering_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPFilteringProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_bgp_filtering_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-filtering-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_filtering_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_filtering_profiles: Annotated[Optional[BgpFilteringProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpFilteringProfiles:
+ """Update a BGP filtering profile
+
+ Update an existing BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_filtering_profiles: OK
+ :type bgp_filtering_profiles: BgpFilteringProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ bgp_filtering_profiles=bgp_filtering_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_filtering_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_filtering_profiles: Annotated[Optional[BgpFilteringProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpFilteringProfiles]:
+ """Update a BGP filtering profile
+
+ Update an existing BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_filtering_profiles: OK
+ :type bgp_filtering_profiles: BgpFilteringProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ bgp_filtering_profiles=bgp_filtering_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_filtering_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_filtering_profiles: Annotated[Optional[BgpFilteringProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a BGP filtering profile
+
+ Update an existing BGP filtering profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_filtering_profiles: OK
+ :type bgp_filtering_profiles: BgpFilteringProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_filtering_profiles_by_id_serialize(
+ id=id,
+ bgp_filtering_profiles=bgp_filtering_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpFilteringProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_bgp_filtering_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single bgp_filtering_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_bgp_filtering_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_bgp_filtering_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_bgp_filtering_profiles_by_id_serialize(
+ self,
+ id,
+ bgp_filtering_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_filtering_profiles is not None:
+ _body_params = bgp_filtering_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bgp-filtering-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/bgp_redistribution_profiles_api.py b/scm/network_services/api/bgp_redistribution_profiles_api.py
new file mode 100644
index 00000000..ceef7337
--- /dev/null
+++ b/scm/network_services/api/bgp_redistribution_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.bgp_redistribution_profiles_list_response import BGPRedistributionProfilesListResponse
+from scm.network_services.models.bgp_redistribution_profiles import BgpRedistributionProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BGPRedistributionProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_redistribution_profiles(
+ self,
+ bgp_redistribution_profiles: Annotated[Optional[BgpRedistributionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRedistributionProfiles:
+ """Create a BGP redistribution profile
+
+ Create a new BGP redistribution profile.
+
+ :param bgp_redistribution_profiles: Created
+ :type bgp_redistribution_profiles: BgpRedistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_redistribution_profiles_serialize(
+ bgp_redistribution_profiles=bgp_redistribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_redistribution_profiles_with_http_info(
+ self,
+ bgp_redistribution_profiles: Annotated[Optional[BgpRedistributionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRedistributionProfiles]:
+ """Create a BGP redistribution profile
+
+ Create a new BGP redistribution profile.
+
+ :param bgp_redistribution_profiles: Created
+ :type bgp_redistribution_profiles: BgpRedistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_redistribution_profiles_serialize(
+ bgp_redistribution_profiles=bgp_redistribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_redistribution_profiles_without_preload_content(
+ self,
+ bgp_redistribution_profiles: Annotated[Optional[BgpRedistributionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a BGP redistribution profile
+
+ Create a new BGP redistribution profile.
+
+ :param bgp_redistribution_profiles: Created
+ :type bgp_redistribution_profiles: BgpRedistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_redistribution_profiles_serialize(
+ bgp_redistribution_profiles=bgp_redistribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_bgp_redistribution_profiles_serialize(
+ self,
+ bgp_redistribution_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_redistribution_profiles is not None:
+ _body_params = bgp_redistribution_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/bgp-redistribution-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_redistribution_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a BGP redistribution profile
+
+ Delete a BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_redistribution_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a BGP redistribution profile
+
+ Delete a BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_redistribution_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a BGP redistribution profile
+
+ Delete a BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_bgp_redistribution_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/bgp-redistribution-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_redistribution_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRedistributionProfiles:
+ """Get a BGP redistribution profile
+
+ Get an existing BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_redistribution_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRedistributionProfiles]:
+ """Get a BGP redistribution profile
+
+ Get an existing BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_redistribution_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a BGP redistribution profile
+
+ Get an existing BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_bgp_redistribution_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-redistribution-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_redistribution_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BGPRedistributionProfilesListResponse:
+ """List BGP redistribution profiles
+
+ Retrieve a list of BGP redistribution profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_redistribution_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRedistributionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_redistribution_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BGPRedistributionProfilesListResponse]:
+ """List BGP redistribution profiles
+
+ Retrieve a list of BGP redistribution profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_redistribution_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRedistributionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_redistribution_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List BGP redistribution profiles
+
+ Retrieve a list of BGP redistribution profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_redistribution_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRedistributionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_bgp_redistribution_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-redistribution-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_redistribution_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_redistribution_profiles: Annotated[Optional[BgpRedistributionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRedistributionProfiles:
+ """Update a BGP redistribution profile
+
+ Update an existing BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_redistribution_profiles: OK
+ :type bgp_redistribution_profiles: BgpRedistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ bgp_redistribution_profiles=bgp_redistribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_redistribution_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_redistribution_profiles: Annotated[Optional[BgpRedistributionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRedistributionProfiles]:
+ """Update a BGP redistribution profile
+
+ Update an existing BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_redistribution_profiles: OK
+ :type bgp_redistribution_profiles: BgpRedistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ bgp_redistribution_profiles=bgp_redistribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_redistribution_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_redistribution_profiles: Annotated[Optional[BgpRedistributionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a BGP redistribution profile
+
+ Update an existing BGP redistribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_redistribution_profiles: OK
+ :type bgp_redistribution_profiles: BgpRedistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_redistribution_profiles_by_id_serialize(
+ id=id,
+ bgp_redistribution_profiles=bgp_redistribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRedistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_bgp_redistribution_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single bgp_redistribution_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_bgp_redistribution_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_bgp_redistribution_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_bgp_redistribution_profiles_by_id_serialize(
+ self,
+ id,
+ bgp_redistribution_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_redistribution_profiles is not None:
+ _body_params = bgp_redistribution_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bgp-redistribution-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/bgp_route_map_redistributions_api.py b/scm/network_services/api/bgp_route_map_redistributions_api.py
new file mode 100644
index 00000000..fa4acd7d
--- /dev/null
+++ b/scm/network_services/api/bgp_route_map_redistributions_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.bgp_route_map_redistributions_list_response import BGPRouteMapRedistributionsListResponse
+from scm.network_services.models.bgp_route_map_redistributions import BgpRouteMapRedistributions
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BGPRouteMapRedistributionsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_route_map_redistributions(
+ self,
+ bgp_route_map_redistributions: Annotated[Optional[BgpRouteMapRedistributions], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouteMapRedistributions:
+ """Create a BGP route map redistribution
+
+ Create a new BGP route map redistribution.
+
+ :param bgp_route_map_redistributions: Created
+ :type bgp_route_map_redistributions: BgpRouteMapRedistributions
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_route_map_redistributions_serialize(
+ bgp_route_map_redistributions=bgp_route_map_redistributions,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_route_map_redistributions_with_http_info(
+ self,
+ bgp_route_map_redistributions: Annotated[Optional[BgpRouteMapRedistributions], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouteMapRedistributions]:
+ """Create a BGP route map redistribution
+
+ Create a new BGP route map redistribution.
+
+ :param bgp_route_map_redistributions: Created
+ :type bgp_route_map_redistributions: BgpRouteMapRedistributions
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_route_map_redistributions_serialize(
+ bgp_route_map_redistributions=bgp_route_map_redistributions,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_route_map_redistributions_without_preload_content(
+ self,
+ bgp_route_map_redistributions: Annotated[Optional[BgpRouteMapRedistributions], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a BGP route map redistribution
+
+ Create a new BGP route map redistribution.
+
+ :param bgp_route_map_redistributions: Created
+ :type bgp_route_map_redistributions: BgpRouteMapRedistributions
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_route_map_redistributions_serialize(
+ bgp_route_map_redistributions=bgp_route_map_redistributions,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_bgp_route_map_redistributions_serialize(
+ self,
+ bgp_route_map_redistributions,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_route_map_redistributions is not None:
+ _body_params = bgp_route_map_redistributions
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/bgp-route-map-redistributions',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_route_map_redistributions_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a BGP route map redistribution
+
+ Delete a BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_route_map_redistributions_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a BGP route map redistribution
+
+ Delete a BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_route_map_redistributions_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a BGP route map redistribution
+
+ Delete a BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_bgp_route_map_redistributions_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/bgp-route-map-redistributions/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_route_map_redistributions_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouteMapRedistributions:
+ """Get a BGP route map redistribution
+
+ Get an existing BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_route_map_redistributions_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouteMapRedistributions]:
+ """Get a BGP route map redistribution
+
+ Get an existing BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_route_map_redistributions_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a BGP route map redistribution
+
+ Get an existing BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_bgp_route_map_redistributions_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-route-map-redistributions/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_route_map_redistributions(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BGPRouteMapRedistributionsListResponse:
+ """List BGP route map redistributions
+
+ Retrieve a list of BGP route map redistributions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_route_map_redistributions_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRouteMapRedistributionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_route_map_redistributions_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BGPRouteMapRedistributionsListResponse]:
+ """List BGP route map redistributions
+
+ Retrieve a list of BGP route map redistributions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_route_map_redistributions_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRouteMapRedistributionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_route_map_redistributions_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List BGP route map redistributions
+
+ Retrieve a list of BGP route map redistributions.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_route_map_redistributions_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRouteMapRedistributionsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_bgp_route_map_redistributions_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-route-map-redistributions',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_route_map_redistributions_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_route_map_redistributions: Annotated[Optional[BgpRouteMapRedistributions], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouteMapRedistributions:
+ """Update a BGP route map redistribution
+
+ Update an existing BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_route_map_redistributions: OK
+ :type bgp_route_map_redistributions: BgpRouteMapRedistributions
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ bgp_route_map_redistributions=bgp_route_map_redistributions,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_route_map_redistributions_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_route_map_redistributions: Annotated[Optional[BgpRouteMapRedistributions], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouteMapRedistributions]:
+ """Update a BGP route map redistribution
+
+ Update an existing BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_route_map_redistributions: OK
+ :type bgp_route_map_redistributions: BgpRouteMapRedistributions
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ bgp_route_map_redistributions=bgp_route_map_redistributions,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_route_map_redistributions_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_route_map_redistributions: Annotated[Optional[BgpRouteMapRedistributions], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a BGP route map redistribution
+
+ Update an existing BGP route map redistribution.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_route_map_redistributions: OK
+ :type bgp_route_map_redistributions: BgpRouteMapRedistributions
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_route_map_redistributions_by_id_serialize(
+ id=id,
+ bgp_route_map_redistributions=bgp_route_map_redistributions,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMapRedistributions",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_bgp_route_map_redistributions(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single bgp_route_map_redistributions object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_bgp_route_map_redistributions(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_bgp_route_map_redistributions(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_bgp_route_map_redistributions_by_id_serialize(
+ self,
+ id,
+ bgp_route_map_redistributions,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_route_map_redistributions is not None:
+ _body_params = bgp_route_map_redistributions
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bgp-route-map-redistributions/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/bgp_route_maps_api.py b/scm/network_services/api/bgp_route_maps_api.py
new file mode 100644
index 00000000..b98fbbb9
--- /dev/null
+++ b/scm/network_services/api/bgp_route_maps_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.bgp_route_maps_list_response import BGPRouteMapsListResponse
+from scm.network_services.models.bgp_route_maps import BgpRouteMaps
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class BGPRouteMapsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_route_maps(
+ self,
+ bgp_route_maps: Annotated[Optional[BgpRouteMaps], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouteMaps:
+ """Create a BGP route map
+
+ Create a new BGP route map.
+
+ :param bgp_route_maps: Created
+ :type bgp_route_maps: BgpRouteMaps
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_route_maps_serialize(
+ bgp_route_maps=bgp_route_maps,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_route_maps_with_http_info(
+ self,
+ bgp_route_maps: Annotated[Optional[BgpRouteMaps], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouteMaps]:
+ """Create a BGP route map
+
+ Create a new BGP route map.
+
+ :param bgp_route_maps: Created
+ :type bgp_route_maps: BgpRouteMaps
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_route_maps_serialize(
+ bgp_route_maps=bgp_route_maps,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_bgp_route_maps_without_preload_content(
+ self,
+ bgp_route_maps: Annotated[Optional[BgpRouteMaps], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a BGP route map
+
+ Create a new BGP route map.
+
+ :param bgp_route_maps: Created
+ :type bgp_route_maps: BgpRouteMaps
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_bgp_route_maps_serialize(
+ bgp_route_maps=bgp_route_maps,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_bgp_route_maps_serialize(
+ self,
+ bgp_route_maps,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_route_maps is not None:
+ _body_params = bgp_route_maps
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/bgp-route-maps',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_route_maps_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a BGP route map
+
+ Delete a BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_route_maps_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_route_maps_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a BGP route map
+
+ Delete a BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_route_maps_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_bgp_route_maps_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a BGP route map
+
+ Delete a BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_bgp_route_maps_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_bgp_route_maps_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/bgp-route-maps/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_route_maps_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouteMaps:
+ """Get a BGP route map
+
+ Get an existing BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_route_maps_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_route_maps_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouteMaps]:
+ """Get a BGP route map
+
+ Get an existing BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_route_maps_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_bgp_route_maps_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a BGP route map
+
+ Get an existing BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_bgp_route_maps_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_bgp_route_maps_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-route-maps/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_route_maps(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BGPRouteMapsListResponse:
+ """List BGP route maps
+
+ Retrieve a list of BGP route maps.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_route_maps_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRouteMapsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_route_maps_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BGPRouteMapsListResponse]:
+ """List BGP route maps
+
+ Retrieve a list of BGP route maps.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_route_maps_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRouteMapsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_bgp_route_maps_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List BGP route maps
+
+ Retrieve a list of BGP route maps.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_bgp_route_maps_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BGPRouteMapsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_bgp_route_maps_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/bgp-route-maps',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_route_maps_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_route_maps: Annotated[Optional[BgpRouteMaps], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> BgpRouteMaps:
+ """Update a BGP route map
+
+ Update an existing BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_route_maps: OK
+ :type bgp_route_maps: BgpRouteMaps
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_route_maps_by_id_serialize(
+ id=id,
+ bgp_route_maps=bgp_route_maps,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_route_maps_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_route_maps: Annotated[Optional[BgpRouteMaps], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[BgpRouteMaps]:
+ """Update a BGP route map
+
+ Update an existing BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_route_maps: OK
+ :type bgp_route_maps: BgpRouteMaps
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_route_maps_by_id_serialize(
+ id=id,
+ bgp_route_maps=bgp_route_maps,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_bgp_route_maps_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ bgp_route_maps: Annotated[Optional[BgpRouteMaps], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a BGP route map
+
+ Update an existing BGP route map.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param bgp_route_maps: OK
+ :type bgp_route_maps: BgpRouteMaps
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_bgp_route_maps_by_id_serialize(
+ id=id,
+ bgp_route_maps=bgp_route_maps,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "BgpRouteMaps",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_bgp_route_maps(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single bgp_route_maps object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_bgp_route_maps(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_bgp_route_maps(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_bgp_route_maps_by_id_serialize(
+ self,
+ id,
+ bgp_route_maps,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if bgp_route_maps is not None:
+ _body_params = bgp_route_maps
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/bgp-route-maps/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/config_match_list_api.py b/scm/network_services/api/config_match_list_api.py
new file mode 100644
index 00000000..6fe9cd29
--- /dev/null
+++ b/scm/network_services/api/config_match_list_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.config_match_list import ConfigMatchList
+from scm.network_services.models.config_match_list_list_response import ConfigMatchListListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ConfigMatchListApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_config_match_list(
+ self,
+ config_match_list: Annotated[Optional[ConfigMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ConfigMatchList:
+ """Create a config match list entry
+
+ Create a new config match list entry.
+
+ :param config_match_list: Created
+ :type config_match_list: ConfigMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_config_match_list_serialize(
+ config_match_list=config_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_config_match_list_with_http_info(
+ self,
+ config_match_list: Annotated[Optional[ConfigMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ConfigMatchList]:
+ """Create a config match list entry
+
+ Create a new config match list entry.
+
+ :param config_match_list: Created
+ :type config_match_list: ConfigMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_config_match_list_serialize(
+ config_match_list=config_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_config_match_list_without_preload_content(
+ self,
+ config_match_list: Annotated[Optional[ConfigMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a config match list entry
+
+ Create a new config match list entry.
+
+ :param config_match_list: Created
+ :type config_match_list: ConfigMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_config_match_list_serialize(
+ config_match_list=config_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_config_match_list_serialize(
+ self,
+ config_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if config_match_list is not None:
+ _body_params = config_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/config-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_config_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a config match list entry
+
+ Delete a config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_config_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_config_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a config match list entry
+
+ Delete a config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_config_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_config_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a config match list entry
+
+ Delete a config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_config_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_config_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/config-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_config_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ConfigMatchList:
+ """Get a config match list entry
+
+ Get an existing config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_config_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_config_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ConfigMatchList]:
+ """Get a config match list entry
+
+ Get an existing config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_config_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_config_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a config match list entry
+
+ Get an existing config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_config_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_config_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/config-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_config_match_list(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ConfigMatchListListResponse:
+ """List config match list entries
+
+ Retrieve a list of config match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_config_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_config_match_list_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ConfigMatchListListResponse]:
+ """List config match list entries
+
+ Retrieve a list of config match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_config_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_config_match_list_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List config match list entries
+
+ Retrieve a list of config match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_config_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_config_match_list_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/config-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_config_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ config_match_list: Annotated[Optional[ConfigMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ConfigMatchList:
+ """Update a config match list entry
+
+ Update an existing config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param config_match_list: OK
+ :type config_match_list: ConfigMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_config_match_list_by_id_serialize(
+ id=id,
+ config_match_list=config_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_config_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ config_match_list: Annotated[Optional[ConfigMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ConfigMatchList]:
+ """Update a config match list entry
+
+ Update an existing config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param config_match_list: OK
+ :type config_match_list: ConfigMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_config_match_list_by_id_serialize(
+ id=id,
+ config_match_list=config_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_config_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ config_match_list: Annotated[Optional[ConfigMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a config match list entry
+
+ Update an existing config match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param config_match_list: OK
+ :type config_match_list: ConfigMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_config_match_list_by_id_serialize(
+ id=id,
+ config_match_list=config_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ConfigMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_config_match_list(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single config_match_list object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_config_match_list(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_config_match_list(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_config_match_list_by_id_serialize(
+ self,
+ id,
+ config_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if config_match_list is not None:
+ _body_params = config_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/config-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/dhcp_interfaces_api.py b/scm/network_services/api/dhcp_interfaces_api.py
new file mode 100644
index 00000000..978430f6
--- /dev/null
+++ b/scm/network_services/api/dhcp_interfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.dhcp_interfaces_list_response import DHCPInterfacesListResponse
+from scm.network_services.models.dhcp_interfaces import DhcpInterfaces
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class DHCPInterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_dhcp_interfaces(
+ self,
+ dhcp_interfaces: Annotated[Optional[DhcpInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DhcpInterfaces:
+ """Create a DHCP interface
+
+ Create a new DHCP interface.
+
+ :param dhcp_interfaces: Created
+ :type dhcp_interfaces: DhcpInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_dhcp_interfaces_serialize(
+ dhcp_interfaces=dhcp_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_dhcp_interfaces_with_http_info(
+ self,
+ dhcp_interfaces: Annotated[Optional[DhcpInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DhcpInterfaces]:
+ """Create a DHCP interface
+
+ Create a new DHCP interface.
+
+ :param dhcp_interfaces: Created
+ :type dhcp_interfaces: DhcpInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_dhcp_interfaces_serialize(
+ dhcp_interfaces=dhcp_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_dhcp_interfaces_without_preload_content(
+ self,
+ dhcp_interfaces: Annotated[Optional[DhcpInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a DHCP interface
+
+ Create a new DHCP interface.
+
+ :param dhcp_interfaces: Created
+ :type dhcp_interfaces: DhcpInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_dhcp_interfaces_serialize(
+ dhcp_interfaces=dhcp_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_dhcp_interfaces_serialize(
+ self,
+ dhcp_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if dhcp_interfaces is not None:
+ _body_params = dhcp_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/dhcp-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_dhcp_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a DHCP interface
+
+ Delete a DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_dhcp_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_dhcp_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a DHCP interface
+
+ Delete a DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_dhcp_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_dhcp_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a DHCP interface
+
+ Delete a DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_dhcp_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_dhcp_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/dhcp-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_dhcp_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DhcpInterfaces:
+ """Get a DHCP interface
+
+ Get an existing DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_dhcp_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_dhcp_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DhcpInterfaces]:
+ """Get a DHCP interface
+
+ Get an existing DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_dhcp_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_dhcp_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a DHCP interface
+
+ Get an existing DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_dhcp_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_dhcp_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/dhcp-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_dhcp_interfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DHCPInterfacesListResponse:
+ """List DHCP interfaces
+
+ Retrieve a list of DHCP interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_dhcp_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DHCPInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_dhcp_interfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DHCPInterfacesListResponse]:
+ """List DHCP interfaces
+
+ Retrieve a list of DHCP interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_dhcp_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DHCPInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_dhcp_interfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List DHCP interfaces
+
+ Retrieve a list of DHCP interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_dhcp_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DHCPInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_dhcp_interfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/dhcp-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_dhcp_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ dhcp_interfaces: Annotated[Optional[DhcpInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DhcpInterfaces:
+ """Update a DHCP interface
+
+ Update an existing DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param dhcp_interfaces: OK
+ :type dhcp_interfaces: DhcpInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_dhcp_interfaces_by_id_serialize(
+ id=id,
+ dhcp_interfaces=dhcp_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_dhcp_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ dhcp_interfaces: Annotated[Optional[DhcpInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DhcpInterfaces]:
+ """Update a DHCP interface
+
+ Update an existing DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param dhcp_interfaces: OK
+ :type dhcp_interfaces: DhcpInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_dhcp_interfaces_by_id_serialize(
+ id=id,
+ dhcp_interfaces=dhcp_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_dhcp_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ dhcp_interfaces: Annotated[Optional[DhcpInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a DHCP interface
+
+ Update an existing DHCP interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param dhcp_interfaces: OK
+ :type dhcp_interfaces: DhcpInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_dhcp_interfaces_by_id_serialize(
+ id=id,
+ dhcp_interfaces=dhcp_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DhcpInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_dhcp_interfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single dhcp_interfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_dhcp_interfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_dhcp_interfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_dhcp_interfaces_by_id_serialize(
+ self,
+ id,
+ dhcp_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if dhcp_interfaces is not None:
+ _body_params = dhcp_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/dhcp-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/dns_proxies_api.py b/scm/network_services/api/dns_proxies_api.py
new file mode 100644
index 00000000..6c83193c
--- /dev/null
+++ b/scm/network_services/api/dns_proxies_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.dns_proxies_list_response import DNSProxiesListResponse
+from scm.network_services.models.dns_proxies import DnsProxies
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class DNSProxiesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_dns_proxies(
+ self,
+ dns_proxies: Annotated[Optional[DnsProxies], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DnsProxies:
+ """Create a DNS proxy
+
+ Create a new DNS proxy.
+
+ :param dns_proxies: Created
+ :type dns_proxies: DnsProxies
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_dns_proxies_serialize(
+ dns_proxies=dns_proxies,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_dns_proxies_with_http_info(
+ self,
+ dns_proxies: Annotated[Optional[DnsProxies], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DnsProxies]:
+ """Create a DNS proxy
+
+ Create a new DNS proxy.
+
+ :param dns_proxies: Created
+ :type dns_proxies: DnsProxies
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_dns_proxies_serialize(
+ dns_proxies=dns_proxies,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_dns_proxies_without_preload_content(
+ self,
+ dns_proxies: Annotated[Optional[DnsProxies], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a DNS proxy
+
+ Create a new DNS proxy.
+
+ :param dns_proxies: Created
+ :type dns_proxies: DnsProxies
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_dns_proxies_serialize(
+ dns_proxies=dns_proxies,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_dns_proxies_serialize(
+ self,
+ dns_proxies,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if dns_proxies is not None:
+ _body_params = dns_proxies
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/dns-proxies',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_dns_proxies_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a DNS proxy
+
+ Delete a DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_dns_proxies_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_dns_proxies_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a DNS proxy
+
+ Delete a DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_dns_proxies_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_dns_proxies_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a DNS proxy
+
+ Delete a DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_dns_proxies_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_dns_proxies_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/dns-proxies/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_dns_proxies_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DnsProxies:
+ """Get a DNS proxy
+
+ Get an existing DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_dns_proxies_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_dns_proxies_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DnsProxies]:
+ """Get a DNS proxy
+
+ Get an existing DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_dns_proxies_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_dns_proxies_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a DNS proxy
+
+ Get an existing DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_dns_proxies_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_dns_proxies_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/dns-proxies/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_dns_proxies(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DNSProxiesListResponse:
+ """List DNS proxies
+
+ Retrieve a list of DNS proxies.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_dns_proxies_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DNSProxiesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_dns_proxies_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DNSProxiesListResponse]:
+ """List DNS proxies
+
+ Retrieve a list of DNS proxies.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_dns_proxies_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DNSProxiesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_dns_proxies_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List DNS proxies
+
+ Retrieve a list of DNS proxies.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_dns_proxies_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DNSProxiesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_dns_proxies_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/dns-proxies',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_dns_proxies_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ dns_proxies: Annotated[Optional[DnsProxies], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> DnsProxies:
+ """Update a DNS proxy
+
+ Update an existing DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param dns_proxies: OK
+ :type dns_proxies: DnsProxies
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_dns_proxies_by_id_serialize(
+ id=id,
+ dns_proxies=dns_proxies,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_dns_proxies_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ dns_proxies: Annotated[Optional[DnsProxies], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[DnsProxies]:
+ """Update a DNS proxy
+
+ Update an existing DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param dns_proxies: OK
+ :type dns_proxies: DnsProxies
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_dns_proxies_by_id_serialize(
+ id=id,
+ dns_proxies=dns_proxies,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_dns_proxies_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ dns_proxies: Annotated[Optional[DnsProxies], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a DNS proxy
+
+ Update an existing DNS proxy.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param dns_proxies: OK
+ :type dns_proxies: DnsProxies
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_dns_proxies_by_id_serialize(
+ id=id,
+ dns_proxies=dns_proxies,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "DnsProxies",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_dns_proxies(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single dns_proxies object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_dns_proxies(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_dns_proxies(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_dns_proxies_by_id_serialize(
+ self,
+ id,
+ dns_proxies,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if dns_proxies is not None:
+ _body_params = dns_proxies
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/dns-proxies/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/ethernet_interfaces_api.py b/scm/network_services/api/ethernet_interfaces_api.py
new file mode 100644
index 00000000..575fadc7
--- /dev/null
+++ b/scm/network_services/api/ethernet_interfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.ethernet_interfaces import EthernetInterfaces
+from scm.network_services.models.ethernet_interfaces_list_response import EthernetInterfacesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class EthernetInterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_ethernet_interfaces(
+ self,
+ ethernet_interfaces: Annotated[Optional[EthernetInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> EthernetInterfaces:
+ """Create an ethernet interface
+
+ Create a new ethernet interface.
+
+ :param ethernet_interfaces: Created
+ :type ethernet_interfaces: EthernetInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ethernet_interfaces_serialize(
+ ethernet_interfaces=ethernet_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_ethernet_interfaces_with_http_info(
+ self,
+ ethernet_interfaces: Annotated[Optional[EthernetInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[EthernetInterfaces]:
+ """Create an ethernet interface
+
+ Create a new ethernet interface.
+
+ :param ethernet_interfaces: Created
+ :type ethernet_interfaces: EthernetInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ethernet_interfaces_serialize(
+ ethernet_interfaces=ethernet_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_ethernet_interfaces_without_preload_content(
+ self,
+ ethernet_interfaces: Annotated[Optional[EthernetInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an ethernet interface
+
+ Create a new ethernet interface.
+
+ :param ethernet_interfaces: Created
+ :type ethernet_interfaces: EthernetInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ethernet_interfaces_serialize(
+ ethernet_interfaces=ethernet_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_ethernet_interfaces_serialize(
+ self,
+ ethernet_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ethernet_interfaces is not None:
+ _body_params = ethernet_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ethernet-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ethernet_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an ethernet interface
+
+ Delete an ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ethernet_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ethernet_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an ethernet interface
+
+ Delete an ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ethernet_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ethernet_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an ethernet interface
+
+ Delete an ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ethernet_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_ethernet_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ethernet-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_ethernet_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> EthernetInterfaces:
+ """Get an ethernet interface
+
+ Get an existing ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ethernet_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_ethernet_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[EthernetInterfaces]:
+ """Get an ethernet interface
+
+ Get an existing ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ethernet_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_ethernet_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an ethernet interface
+
+ Get an existing ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ethernet_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_ethernet_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ethernet-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_ethernet_interfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> EthernetInterfacesListResponse:
+ """List ethernet interfaces
+
+ Retrieve a list of ethernet interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ethernet_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_ethernet_interfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[EthernetInterfacesListResponse]:
+ """List ethernet interfaces
+
+ Retrieve a list of ethernet interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ethernet_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_ethernet_interfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List ethernet interfaces
+
+ Retrieve a list of ethernet interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ethernet_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_ethernet_interfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ethernet-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_ethernet_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ethernet_interfaces: Annotated[Optional[EthernetInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> EthernetInterfaces:
+ """Update an ethernet interface
+
+ Update an existing ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ethernet_interfaces: OK
+ :type ethernet_interfaces: EthernetInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ethernet_interfaces_by_id_serialize(
+ id=id,
+ ethernet_interfaces=ethernet_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_ethernet_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ethernet_interfaces: Annotated[Optional[EthernetInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[EthernetInterfaces]:
+ """Update an ethernet interface
+
+ Update an existing ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ethernet_interfaces: OK
+ :type ethernet_interfaces: EthernetInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ethernet_interfaces_by_id_serialize(
+ id=id,
+ ethernet_interfaces=ethernet_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_ethernet_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ethernet_interfaces: Annotated[Optional[EthernetInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an ethernet interface
+
+ Update an existing ethernet interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ethernet_interfaces: OK
+ :type ethernet_interfaces: EthernetInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ethernet_interfaces_by_id_serialize(
+ id=id,
+ ethernet_interfaces=ethernet_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "EthernetInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ethernet_interfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ethernet_interfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ethernet_interfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_ethernet_interfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_ethernet_interfaces_by_id_serialize(
+ self,
+ id,
+ ethernet_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ethernet_interfaces is not None:
+ _body_params = ethernet_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ethernet-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/globalprotect_match_list_api.py b/scm/network_services/api/globalprotect_match_list_api.py
new file mode 100644
index 00000000..d5c754a4
--- /dev/null
+++ b/scm/network_services/api/globalprotect_match_list_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.globalprotect_match_list import GlobalprotectMatchList
+from scm.network_services.models.globalprotect_match_list_list_response import GlobalprotectMatchListListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class GlobalprotectMatchListApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_globalprotect_match_list(
+ self,
+ globalprotect_match_list: Annotated[Optional[GlobalprotectMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GlobalprotectMatchList:
+ """Create a globalprotect match list entry
+
+ Create a new globalprotect match list entry.
+
+ :param globalprotect_match_list: Created
+ :type globalprotect_match_list: GlobalprotectMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_globalprotect_match_list_serialize(
+ globalprotect_match_list=globalprotect_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_globalprotect_match_list_with_http_info(
+ self,
+ globalprotect_match_list: Annotated[Optional[GlobalprotectMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GlobalprotectMatchList]:
+ """Create a globalprotect match list entry
+
+ Create a new globalprotect match list entry.
+
+ :param globalprotect_match_list: Created
+ :type globalprotect_match_list: GlobalprotectMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_globalprotect_match_list_serialize(
+ globalprotect_match_list=globalprotect_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_globalprotect_match_list_without_preload_content(
+ self,
+ globalprotect_match_list: Annotated[Optional[GlobalprotectMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a globalprotect match list entry
+
+ Create a new globalprotect match list entry.
+
+ :param globalprotect_match_list: Created
+ :type globalprotect_match_list: GlobalprotectMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_globalprotect_match_list_serialize(
+ globalprotect_match_list=globalprotect_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_globalprotect_match_list_serialize(
+ self,
+ globalprotect_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if globalprotect_match_list is not None:
+ _body_params = globalprotect_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/globalprotect-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_globalprotect_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a globalprotect match list entry
+
+ Delete a globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_globalprotect_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_globalprotect_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a globalprotect match list entry
+
+ Delete a globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_globalprotect_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_globalprotect_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a globalprotect match list entry
+
+ Delete a globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_globalprotect_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_globalprotect_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/globalprotect-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_globalprotect_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GlobalprotectMatchList:
+ """Get a globalprotect match list entry
+
+ Get an existing globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_globalprotect_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_globalprotect_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GlobalprotectMatchList]:
+ """Get a globalprotect match list entry
+
+ Get an existing globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_globalprotect_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_globalprotect_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a globalprotect match list entry
+
+ Get an existing globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_globalprotect_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_globalprotect_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/globalprotect-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_globalprotect_match_list(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GlobalprotectMatchListListResponse:
+ """List globalprotect match list entries
+
+ Retrieve a list of globalprotect match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_globalprotect_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_globalprotect_match_list_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GlobalprotectMatchListListResponse]:
+ """List globalprotect match list entries
+
+ Retrieve a list of globalprotect match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_globalprotect_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_globalprotect_match_list_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List globalprotect match list entries
+
+ Retrieve a list of globalprotect match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_globalprotect_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_globalprotect_match_list_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/globalprotect-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_globalprotect_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ globalprotect_match_list: Annotated[Optional[GlobalprotectMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> GlobalprotectMatchList:
+ """Update a globalprotect match list entry
+
+ Update an existing globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param globalprotect_match_list: OK
+ :type globalprotect_match_list: GlobalprotectMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_globalprotect_match_list_by_id_serialize(
+ id=id,
+ globalprotect_match_list=globalprotect_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_globalprotect_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ globalprotect_match_list: Annotated[Optional[GlobalprotectMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[GlobalprotectMatchList]:
+ """Update a globalprotect match list entry
+
+ Update an existing globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param globalprotect_match_list: OK
+ :type globalprotect_match_list: GlobalprotectMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_globalprotect_match_list_by_id_serialize(
+ id=id,
+ globalprotect_match_list=globalprotect_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_globalprotect_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ globalprotect_match_list: Annotated[Optional[GlobalprotectMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a globalprotect match list entry
+
+ Update an existing globalprotect match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param globalprotect_match_list: OK
+ :type globalprotect_match_list: GlobalprotectMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_globalprotect_match_list_by_id_serialize(
+ id=id,
+ globalprotect_match_list=globalprotect_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "GlobalprotectMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_globalprotect_match_list(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single globalprotect_match_list object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_globalprotect_match_list(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_globalprotect_match_list(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_globalprotect_match_list_by_id_serialize(
+ self,
+ id,
+ globalprotect_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if globalprotect_match_list is not None:
+ _body_params = globalprotect_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/globalprotect-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/hipmatch_match_list_api.py b/scm/network_services/api/hipmatch_match_list_api.py
new file mode 100644
index 00000000..2a7bbc62
--- /dev/null
+++ b/scm/network_services/api/hipmatch_match_list_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.hipmatch_match_list import HipmatchMatchList
+from scm.network_services.models.hipmatch_match_list_list_response import HipmatchMatchListListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class HipmatchMatchListApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_hipmatch_match_list(
+ self,
+ hipmatch_match_list: Annotated[Optional[HipmatchMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> HipmatchMatchList:
+ """Create a hipmatch match list entry
+
+ Create a new hipmatch match list entry.
+
+ :param hipmatch_match_list: Created
+ :type hipmatch_match_list: HipmatchMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_hipmatch_match_list_serialize(
+ hipmatch_match_list=hipmatch_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_hipmatch_match_list_with_http_info(
+ self,
+ hipmatch_match_list: Annotated[Optional[HipmatchMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[HipmatchMatchList]:
+ """Create a hipmatch match list entry
+
+ Create a new hipmatch match list entry.
+
+ :param hipmatch_match_list: Created
+ :type hipmatch_match_list: HipmatchMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_hipmatch_match_list_serialize(
+ hipmatch_match_list=hipmatch_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_hipmatch_match_list_without_preload_content(
+ self,
+ hipmatch_match_list: Annotated[Optional[HipmatchMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a hipmatch match list entry
+
+ Create a new hipmatch match list entry.
+
+ :param hipmatch_match_list: Created
+ :type hipmatch_match_list: HipmatchMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_hipmatch_match_list_serialize(
+ hipmatch_match_list=hipmatch_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_hipmatch_match_list_serialize(
+ self,
+ hipmatch_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if hipmatch_match_list is not None:
+ _body_params = hipmatch_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/hipmatch-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_hipmatch_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a hipmatch match list entry
+
+ Delete a hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_hipmatch_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_hipmatch_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a hipmatch match list entry
+
+ Delete a hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_hipmatch_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_hipmatch_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a hipmatch match list entry
+
+ Delete a hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_hipmatch_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_hipmatch_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/hipmatch-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_hipmatch_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> HipmatchMatchList:
+ """Get a hipmatch match list entry
+
+ Get an existing hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_hipmatch_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_hipmatch_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[HipmatchMatchList]:
+ """Get a hipmatch match list entry
+
+ Get an existing hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_hipmatch_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_hipmatch_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a hipmatch match list entry
+
+ Get an existing hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_hipmatch_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_hipmatch_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/hipmatch-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_hipmatch_match_list(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> HipmatchMatchListListResponse:
+ """List hipmatch match list entries
+
+ Retrieve a list of hipmatch match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_hipmatch_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_hipmatch_match_list_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[HipmatchMatchListListResponse]:
+ """List hipmatch match list entries
+
+ Retrieve a list of hipmatch match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_hipmatch_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_hipmatch_match_list_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List hipmatch match list entries
+
+ Retrieve a list of hipmatch match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_hipmatch_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_hipmatch_match_list_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/hipmatch-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_hipmatch_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ hipmatch_match_list: Annotated[Optional[HipmatchMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> HipmatchMatchList:
+ """Update a hipmatch match list entry
+
+ Update an existing hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param hipmatch_match_list: OK
+ :type hipmatch_match_list: HipmatchMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_hipmatch_match_list_by_id_serialize(
+ id=id,
+ hipmatch_match_list=hipmatch_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_hipmatch_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ hipmatch_match_list: Annotated[Optional[HipmatchMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[HipmatchMatchList]:
+ """Update a hipmatch match list entry
+
+ Update an existing hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param hipmatch_match_list: OK
+ :type hipmatch_match_list: HipmatchMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_hipmatch_match_list_by_id_serialize(
+ id=id,
+ hipmatch_match_list=hipmatch_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_hipmatch_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ hipmatch_match_list: Annotated[Optional[HipmatchMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a hipmatch match list entry
+
+ Update an existing hipmatch match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param hipmatch_match_list: OK
+ :type hipmatch_match_list: HipmatchMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_hipmatch_match_list_by_id_serialize(
+ id=id,
+ hipmatch_match_list=hipmatch_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "HipmatchMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_hipmatch_match_list(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single hipmatch_match_list object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_hipmatch_match_list(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_hipmatch_match_list(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_hipmatch_match_list_by_id_serialize(
+ self,
+ id,
+ hipmatch_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if hipmatch_match_list is not None:
+ _body_params = hipmatch_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/hipmatch-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/ike_crypto_profiles_api.py b/scm/network_services/api/ike_crypto_profiles_api.py
new file mode 100644
index 00000000..8ea69ebe
--- /dev/null
+++ b/scm/network_services/api/ike_crypto_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.ike_crypto_profiles_list_response import IKECryptoProfilesListResponse
+from scm.network_services.models.ike_crypto_profiles import IkeCryptoProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class IKECryptoProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_ike_crypto_profiles(
+ self,
+ ike_crypto_profiles: Annotated[Optional[IkeCryptoProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IkeCryptoProfiles:
+ """Create an IKE crypto profile
+
+ Create a new IKE crypto profile.
+
+ :param ike_crypto_profiles: Created
+ :type ike_crypto_profiles: IkeCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ike_crypto_profiles_serialize(
+ ike_crypto_profiles=ike_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_ike_crypto_profiles_with_http_info(
+ self,
+ ike_crypto_profiles: Annotated[Optional[IkeCryptoProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IkeCryptoProfiles]:
+ """Create an IKE crypto profile
+
+ Create a new IKE crypto profile.
+
+ :param ike_crypto_profiles: Created
+ :type ike_crypto_profiles: IkeCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ike_crypto_profiles_serialize(
+ ike_crypto_profiles=ike_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_ike_crypto_profiles_without_preload_content(
+ self,
+ ike_crypto_profiles: Annotated[Optional[IkeCryptoProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an IKE crypto profile
+
+ Create a new IKE crypto profile.
+
+ :param ike_crypto_profiles: Created
+ :type ike_crypto_profiles: IkeCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ike_crypto_profiles_serialize(
+ ike_crypto_profiles=ike_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_ike_crypto_profiles_serialize(
+ self,
+ ike_crypto_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ike_crypto_profiles is not None:
+ _body_params = ike_crypto_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ike-crypto-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ike_crypto_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an IKE crypto profile
+
+ Delete an IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ike_crypto_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an IKE crypto profile
+
+ Delete an IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ike_crypto_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an IKE crypto profile
+
+ Delete an IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_ike_crypto_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ike-crypto-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_ike_crypto_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IkeCryptoProfiles:
+ """Get an IKE crypto profile
+
+ Get an existing IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_ike_crypto_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IkeCryptoProfiles]:
+ """Get an IKE crypto profile
+
+ Get an existing IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_ike_crypto_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an IKE crypto profile
+
+ Get an existing IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_ike_crypto_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ike-crypto-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_ike_crypto_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IKECryptoProfilesListResponse:
+ """List IKE crypto profiles
+
+ Retrieve a list of IKE crypto profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ike_crypto_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IKECryptoProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_ike_crypto_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IKECryptoProfilesListResponse]:
+ """List IKE crypto profiles
+
+ Retrieve a list of IKE crypto profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ike_crypto_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IKECryptoProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_ike_crypto_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List IKE crypto profiles
+
+ Retrieve a list of IKE crypto profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ike_crypto_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IKECryptoProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_ike_crypto_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ike-crypto-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_ike_crypto_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ike_crypto_profiles: Annotated[Optional[IkeCryptoProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IkeCryptoProfiles:
+ """Update an IKE crypto profile
+
+ Update an existing IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ike_crypto_profiles: OK
+ :type ike_crypto_profiles: IkeCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ ike_crypto_profiles=ike_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_ike_crypto_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ike_crypto_profiles: Annotated[Optional[IkeCryptoProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IkeCryptoProfiles]:
+ """Update an IKE crypto profile
+
+ Update an existing IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ike_crypto_profiles: OK
+ :type ike_crypto_profiles: IkeCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ ike_crypto_profiles=ike_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_ike_crypto_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ike_crypto_profiles: Annotated[Optional[IkeCryptoProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an IKE crypto profile
+
+ Update an existing IKE crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ike_crypto_profiles: OK
+ :type ike_crypto_profiles: IkeCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ike_crypto_profiles_by_id_serialize(
+ id=id,
+ ike_crypto_profiles=ike_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ike_crypto_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ike_crypto_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ike_crypto_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_ike_crypto_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_ike_crypto_profiles_by_id_serialize(
+ self,
+ id,
+ ike_crypto_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ike_crypto_profiles is not None:
+ _body_params = ike_crypto_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ike-crypto-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/ike_gateways_api.py b/scm/network_services/api/ike_gateways_api.py
new file mode 100644
index 00000000..a76a18bc
--- /dev/null
+++ b/scm/network_services/api/ike_gateways_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.ike_gateways_list_response import IKEGatewaysListResponse
+from scm.network_services.models.ike_gateways import IkeGateways
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class IKEGatewaysApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_ike_gateways(
+ self,
+ ike_gateways: Annotated[Optional[IkeGateways], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IkeGateways:
+ """Create an IKE gateway
+
+ Create a new IKE gateway.
+
+ :param ike_gateways: Created
+ :type ike_gateways: IkeGateways
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ike_gateways_serialize(
+ ike_gateways=ike_gateways,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_ike_gateways_with_http_info(
+ self,
+ ike_gateways: Annotated[Optional[IkeGateways], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IkeGateways]:
+ """Create an IKE gateway
+
+ Create a new IKE gateway.
+
+ :param ike_gateways: Created
+ :type ike_gateways: IkeGateways
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ike_gateways_serialize(
+ ike_gateways=ike_gateways,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_ike_gateways_without_preload_content(
+ self,
+ ike_gateways: Annotated[Optional[IkeGateways], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an IKE gateway
+
+ Create a new IKE gateway.
+
+ :param ike_gateways: Created
+ :type ike_gateways: IkeGateways
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ike_gateways_serialize(
+ ike_gateways=ike_gateways,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_ike_gateways_serialize(
+ self,
+ ike_gateways,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ike_gateways is not None:
+ _body_params = ike_gateways
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ike-gateways',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ike_gateways_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an IKE gateway
+
+ Delete an IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ike_gateways_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ike_gateways_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an IKE gateway
+
+ Delete an IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ike_gateways_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ike_gateways_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an IKE gateway
+
+ Delete an IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ike_gateways_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_ike_gateways_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ike-gateways/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_ike_gateways_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IkeGateways:
+ """Get an IKE gateway
+
+ Get an existing IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ike_gateways_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_ike_gateways_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IkeGateways]:
+ """Get an IKE gateway
+
+ Get an existing IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ike_gateways_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_ike_gateways_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an IKE gateway
+
+ Get an existing IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ike_gateways_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_ike_gateways_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ike-gateways/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_ike_gateways(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IKEGatewaysListResponse:
+ """List IKE gateways
+
+ Retrieve a list of IKE gateways.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ike_gateways_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IKEGatewaysListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_ike_gateways_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IKEGatewaysListResponse]:
+ """List IKE gateways
+
+ Retrieve a list of IKE gateways.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ike_gateways_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IKEGatewaysListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_ike_gateways_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List IKE gateways
+
+ Retrieve a list of IKE gateways.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ike_gateways_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IKEGatewaysListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_ike_gateways_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ike-gateways',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_ike_gateways_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ike_gateways: Annotated[Optional[IkeGateways], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IkeGateways:
+ """Update an IKE gateway
+
+ Update an IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ike_gateways: OK
+ :type ike_gateways: IkeGateways
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ike_gateways_by_id_serialize(
+ id=id,
+ ike_gateways=ike_gateways,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_ike_gateways_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ike_gateways: Annotated[Optional[IkeGateways], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IkeGateways]:
+ """Update an IKE gateway
+
+ Update an IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ike_gateways: OK
+ :type ike_gateways: IkeGateways
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ike_gateways_by_id_serialize(
+ id=id,
+ ike_gateways=ike_gateways,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_ike_gateways_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ike_gateways: Annotated[Optional[IkeGateways], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an IKE gateway
+
+ Update an IKE gateway.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ike_gateways: OK
+ :type ike_gateways: IkeGateways
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ike_gateways_by_id_serialize(
+ id=id,
+ ike_gateways=ike_gateways,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IkeGateways",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ike_gateways(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ike_gateways object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ike_gateways(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_ike_gateways(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_ike_gateways_by_id_serialize(
+ self,
+ id,
+ ike_gateways,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ike_gateways is not None:
+ _body_params = ike_gateways
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ike-gateways/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/interface_management_profiles_api.py b/scm/network_services/api/interface_management_profiles_api.py
new file mode 100644
index 00000000..6f4b99d5
--- /dev/null
+++ b/scm/network_services/api/interface_management_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.interface_management_profiles import InterfaceManagementProfiles
+from scm.network_services.models.interface_management_profiles_list_response import InterfaceManagementProfilesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class InterfaceManagementProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_interface_management_profiles(
+ self,
+ interface_management_profiles: Annotated[Optional[InterfaceManagementProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InterfaceManagementProfiles:
+ """Create a interface management profiles
+
+ Create a new interface management profile.
+
+ :param interface_management_profiles: Created
+ :type interface_management_profiles: InterfaceManagementProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_interface_management_profiles_serialize(
+ interface_management_profiles=interface_management_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_interface_management_profiles_with_http_info(
+ self,
+ interface_management_profiles: Annotated[Optional[InterfaceManagementProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InterfaceManagementProfiles]:
+ """Create a interface management profiles
+
+ Create a new interface management profile.
+
+ :param interface_management_profiles: Created
+ :type interface_management_profiles: InterfaceManagementProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_interface_management_profiles_serialize(
+ interface_management_profiles=interface_management_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_interface_management_profiles_without_preload_content(
+ self,
+ interface_management_profiles: Annotated[Optional[InterfaceManagementProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a interface management profiles
+
+ Create a new interface management profile.
+
+ :param interface_management_profiles: Created
+ :type interface_management_profiles: InterfaceManagementProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_interface_management_profiles_serialize(
+ interface_management_profiles=interface_management_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_interface_management_profiles_serialize(
+ self,
+ interface_management_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if interface_management_profiles is not None:
+ _body_params = interface_management_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/interface-management-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_interface_management_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an interface management profile
+
+ Delete an interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_interface_management_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_interface_management_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an interface management profile
+
+ Delete an interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_interface_management_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_interface_management_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an interface management profile
+
+ Delete an interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_interface_management_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_interface_management_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/interface-management-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_interface_management_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InterfaceManagementProfiles:
+ """Get an interface management profile
+
+ Get an existing interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_interface_management_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_interface_management_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InterfaceManagementProfiles]:
+ """Get an interface management profile
+
+ Get an existing interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_interface_management_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_interface_management_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an interface management profile
+
+ Get an existing interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_interface_management_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_interface_management_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/interface-management-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_interface_management_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InterfaceManagementProfilesListResponse:
+ """List interface management profiles
+
+ Retrieve a list of interface management profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_interface_management_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_interface_management_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InterfaceManagementProfilesListResponse]:
+ """List interface management profiles
+
+ Retrieve a list of interface management profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_interface_management_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_interface_management_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List interface management profiles
+
+ Retrieve a list of interface management profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_interface_management_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_interface_management_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/interface-management-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_interface_management_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ interface_management_profiles: Annotated[Optional[InterfaceManagementProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> InterfaceManagementProfiles:
+ """Update an interface management profile
+
+ Update an existing interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param interface_management_profiles: OK
+ :type interface_management_profiles: InterfaceManagementProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_interface_management_profiles_by_id_serialize(
+ id=id,
+ interface_management_profiles=interface_management_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_interface_management_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ interface_management_profiles: Annotated[Optional[InterfaceManagementProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[InterfaceManagementProfiles]:
+ """Update an interface management profile
+
+ Update an existing interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param interface_management_profiles: OK
+ :type interface_management_profiles: InterfaceManagementProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_interface_management_profiles_by_id_serialize(
+ id=id,
+ interface_management_profiles=interface_management_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_interface_management_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ interface_management_profiles: Annotated[Optional[InterfaceManagementProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an interface management profile
+
+ Update an existing interface management profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param interface_management_profiles: OK
+ :type interface_management_profiles: InterfaceManagementProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_interface_management_profiles_by_id_serialize(
+ id=id,
+ interface_management_profiles=interface_management_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "InterfaceManagementProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_interface_management_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single interface_management_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_interface_management_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_interface_management_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_interface_management_profiles_by_id_serialize(
+ self,
+ id,
+ interface_management_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if interface_management_profiles is not None:
+ _body_params = interface_management_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/interface-management-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/ipsec_crypto_profiles_api.py b/scm/network_services/api/ipsec_crypto_profiles_api.py
new file mode 100644
index 00000000..03e248d7
--- /dev/null
+++ b/scm/network_services/api/ipsec_crypto_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.ipsec_crypto_profiles_list_response import IPsecCryptoProfilesListResponse
+from scm.network_services.models.ipsec_crypto_profiles import IpsecCryptoProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class IPsecCryptoProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_i_psec_crypto_profiles(
+ self,
+ ipsec_crypto_profiles: Annotated[Optional[IpsecCryptoProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IpsecCryptoProfiles:
+ """Create an IPsec crypto profile
+
+ Create a new IPsec crypto profile.
+
+ :param ipsec_crypto_profiles: Created
+ :type ipsec_crypto_profiles: IpsecCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_i_psec_crypto_profiles_serialize(
+ ipsec_crypto_profiles=ipsec_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_i_psec_crypto_profiles_with_http_info(
+ self,
+ ipsec_crypto_profiles: Annotated[Optional[IpsecCryptoProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IpsecCryptoProfiles]:
+ """Create an IPsec crypto profile
+
+ Create a new IPsec crypto profile.
+
+ :param ipsec_crypto_profiles: Created
+ :type ipsec_crypto_profiles: IpsecCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_i_psec_crypto_profiles_serialize(
+ ipsec_crypto_profiles=ipsec_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_i_psec_crypto_profiles_without_preload_content(
+ self,
+ ipsec_crypto_profiles: Annotated[Optional[IpsecCryptoProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an IPsec crypto profile
+
+ Create a new IPsec crypto profile.
+
+ :param ipsec_crypto_profiles: Created
+ :type ipsec_crypto_profiles: IpsecCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_i_psec_crypto_profiles_serialize(
+ ipsec_crypto_profiles=ipsec_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_i_psec_crypto_profiles_serialize(
+ self,
+ ipsec_crypto_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ipsec_crypto_profiles is not None:
+ _body_params = ipsec_crypto_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ipsec-crypto-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_i_psec_crypto_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an IPsec crypto profile
+
+ Delete an IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_i_psec_crypto_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an IPsec crypto profile
+
+ Delete an IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_i_psec_crypto_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an IPsec crypto profile
+
+ Delete an IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_i_psec_crypto_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ipsec-crypto-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_i_psec_crypto_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IpsecCryptoProfiles:
+ """Get an IPsec crypto profile
+
+ Get an existing IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_i_psec_crypto_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IpsecCryptoProfiles]:
+ """Get an IPsec crypto profile
+
+ Get an existing IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_i_psec_crypto_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an IPsec crypto profile
+
+ Get an existing IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_i_psec_crypto_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ipsec-crypto-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_i_psec_crypto_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IPsecCryptoProfilesListResponse:
+ """List IPsec crypto profiles
+
+ Retrieve a list of IPsec crypto profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_i_psec_crypto_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IPsecCryptoProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_i_psec_crypto_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IPsecCryptoProfilesListResponse]:
+ """List IPsec crypto profiles
+
+ Retrieve a list of IPsec crypto profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_i_psec_crypto_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IPsecCryptoProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_i_psec_crypto_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List IPsec crypto profiles
+
+ Retrieve a list of IPsec crypto profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_i_psec_crypto_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IPsecCryptoProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_i_psec_crypto_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ipsec-crypto-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_i_psec_crypto_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ipsec_crypto_profiles: Annotated[Optional[IpsecCryptoProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IpsecCryptoProfiles:
+ """Update an IPsec crypto profile
+
+ Update an IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ipsec_crypto_profiles: OK
+ :type ipsec_crypto_profiles: IpsecCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ ipsec_crypto_profiles=ipsec_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_i_psec_crypto_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ipsec_crypto_profiles: Annotated[Optional[IpsecCryptoProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IpsecCryptoProfiles]:
+ """Update an IPsec crypto profile
+
+ Update an IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ipsec_crypto_profiles: OK
+ :type ipsec_crypto_profiles: IpsecCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ ipsec_crypto_profiles=ipsec_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_i_psec_crypto_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ipsec_crypto_profiles: Annotated[Optional[IpsecCryptoProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an IPsec crypto profile
+
+ Update an IPsec crypto profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ipsec_crypto_profiles: OK
+ :type ipsec_crypto_profiles: IpsecCryptoProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_i_psec_crypto_profiles_by_id_serialize(
+ id=id,
+ ipsec_crypto_profiles=ipsec_crypto_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecCryptoProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ipsec_crypto_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ipsec_crypto_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ipsec_crypto_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_i_psec_crypto_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_i_psec_crypto_profiles_by_id_serialize(
+ self,
+ id,
+ ipsec_crypto_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ipsec_crypto_profiles is not None:
+ _body_params = ipsec_crypto_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ipsec-crypto-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/ipsec_tunnels_api.py b/scm/network_services/api/ipsec_tunnels_api.py
new file mode 100644
index 00000000..fa02a820
--- /dev/null
+++ b/scm/network_services/api/ipsec_tunnels_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.ipsec_tunnels_list_response import IPsecTunnelsListResponse
+from scm.network_services.models.ipsec_tunnels import IpsecTunnels
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class IPsecTunnelsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_i_psec_tunnels(
+ self,
+ ipsec_tunnels: Annotated[Optional[IpsecTunnels], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IpsecTunnels:
+ """Create an IPsec tunnel
+
+ Create a new IPsec tunnel.
+
+ :param ipsec_tunnels: Created
+ :type ipsec_tunnels: IpsecTunnels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_i_psec_tunnels_serialize(
+ ipsec_tunnels=ipsec_tunnels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_i_psec_tunnels_with_http_info(
+ self,
+ ipsec_tunnels: Annotated[Optional[IpsecTunnels], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IpsecTunnels]:
+ """Create an IPsec tunnel
+
+ Create a new IPsec tunnel.
+
+ :param ipsec_tunnels: Created
+ :type ipsec_tunnels: IpsecTunnels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_i_psec_tunnels_serialize(
+ ipsec_tunnels=ipsec_tunnels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_i_psec_tunnels_without_preload_content(
+ self,
+ ipsec_tunnels: Annotated[Optional[IpsecTunnels], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an IPsec tunnel
+
+ Create a new IPsec tunnel.
+
+ :param ipsec_tunnels: Created
+ :type ipsec_tunnels: IpsecTunnels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_i_psec_tunnels_serialize(
+ ipsec_tunnels=ipsec_tunnels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_i_psec_tunnels_serialize(
+ self,
+ ipsec_tunnels,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ipsec_tunnels is not None:
+ _body_params = ipsec_tunnels
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ipsec-tunnels',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_i_psec_tunnels_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an IPsec tunnel
+
+ Delete an IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_i_psec_tunnels_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_i_psec_tunnels_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an IPsec tunnel
+
+ Delete an IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_i_psec_tunnels_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_i_psec_tunnels_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an IPsec tunnel
+
+ Delete an IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_i_psec_tunnels_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_i_psec_tunnels_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ipsec-tunnels/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_i_psec_tunnels_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IpsecTunnels:
+ """Get an IPsec tunnel
+
+ Get an existing IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_i_psec_tunnels_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_i_psec_tunnels_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IpsecTunnels]:
+ """Get an IPsec tunnel
+
+ Get an existing IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_i_psec_tunnels_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_i_psec_tunnels_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an IPsec tunnel
+
+ Get an existing IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_i_psec_tunnels_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_i_psec_tunnels_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ipsec-tunnels/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_i_psec_tunnels(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IPsecTunnelsListResponse:
+ """List IPsec tunnels
+
+ Retrieve a list of IPsec tunnels.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_i_psec_tunnels_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IPsecTunnelsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_i_psec_tunnels_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IPsecTunnelsListResponse]:
+ """List IPsec tunnels
+
+ Retrieve a list of IPsec tunnels.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_i_psec_tunnels_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IPsecTunnelsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_i_psec_tunnels_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List IPsec tunnels
+
+ Retrieve a list of IPsec tunnels.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_i_psec_tunnels_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IPsecTunnelsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_i_psec_tunnels_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ipsec-tunnels',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_i_psec_tunnels_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ipsec_tunnels: Annotated[Optional[IpsecTunnels], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IpsecTunnels:
+ """Update an IPsec tunnel
+
+ Update an existing IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ipsec_tunnels: OK
+ :type ipsec_tunnels: IpsecTunnels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_i_psec_tunnels_by_id_serialize(
+ id=id,
+ ipsec_tunnels=ipsec_tunnels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_i_psec_tunnels_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ipsec_tunnels: Annotated[Optional[IpsecTunnels], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IpsecTunnels]:
+ """Update an IPsec tunnel
+
+ Update an existing IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ipsec_tunnels: OK
+ :type ipsec_tunnels: IpsecTunnels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_i_psec_tunnels_by_id_serialize(
+ id=id,
+ ipsec_tunnels=ipsec_tunnels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_i_psec_tunnels_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ipsec_tunnels: Annotated[Optional[IpsecTunnels], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an IPsec tunnel
+
+ Update an existing IPsec tunnel.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ipsec_tunnels: OK
+ :type ipsec_tunnels: IpsecTunnels
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_i_psec_tunnels_by_id_serialize(
+ id=id,
+ ipsec_tunnels=ipsec_tunnels,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IpsecTunnels",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ipsec_tunnels(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ipsec_tunnels object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ipsec_tunnels(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_i_psec_tunnels(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_i_psec_tunnels_by_id_serialize(
+ self,
+ id,
+ ipsec_tunnels,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ipsec_tunnels is not None:
+ _body_params = ipsec_tunnels
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ipsec-tunnels/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/iptag_match_list_api.py b/scm/network_services/api/iptag_match_list_api.py
new file mode 100644
index 00000000..3250b381
--- /dev/null
+++ b/scm/network_services/api/iptag_match_list_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.iptag_match_list import IptagMatchList
+from scm.network_services.models.iptag_match_list_list_response import IptagMatchListListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class IptagMatchListApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_iptag_match_list(
+ self,
+ iptag_match_list: Annotated[Optional[IptagMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IptagMatchList:
+ """Create an iptag match list entry
+
+ Create a new iptag match list entry.
+
+ :param iptag_match_list: Created
+ :type iptag_match_list: IptagMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_iptag_match_list_serialize(
+ iptag_match_list=iptag_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_iptag_match_list_with_http_info(
+ self,
+ iptag_match_list: Annotated[Optional[IptagMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IptagMatchList]:
+ """Create an iptag match list entry
+
+ Create a new iptag match list entry.
+
+ :param iptag_match_list: Created
+ :type iptag_match_list: IptagMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_iptag_match_list_serialize(
+ iptag_match_list=iptag_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_iptag_match_list_without_preload_content(
+ self,
+ iptag_match_list: Annotated[Optional[IptagMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an iptag match list entry
+
+ Create a new iptag match list entry.
+
+ :param iptag_match_list: Created
+ :type iptag_match_list: IptagMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_iptag_match_list_serialize(
+ iptag_match_list=iptag_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_iptag_match_list_serialize(
+ self,
+ iptag_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if iptag_match_list is not None:
+ _body_params = iptag_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/iptag-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_iptag_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an iptag match list entry
+
+ Delete an iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_iptag_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_iptag_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an iptag match list entry
+
+ Delete an iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_iptag_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_iptag_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an iptag match list entry
+
+ Delete an iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_iptag_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_iptag_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/iptag-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_iptag_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IptagMatchList:
+ """Get an iptag match list entry
+
+ Get an existing iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_iptag_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_iptag_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IptagMatchList]:
+ """Get an iptag match list entry
+
+ Get an existing iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_iptag_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_iptag_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an iptag match list entry
+
+ Get an existing iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_iptag_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_iptag_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/iptag-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_iptag_match_list(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IptagMatchListListResponse:
+ """List iptag match list entries
+
+ Retrieve a list of iptag match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_iptag_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_iptag_match_list_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IptagMatchListListResponse]:
+ """List iptag match list entries
+
+ Retrieve a list of iptag match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_iptag_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_iptag_match_list_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List iptag match list entries
+
+ Retrieve a list of iptag match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_iptag_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_iptag_match_list_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/iptag-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_iptag_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ iptag_match_list: Annotated[Optional[IptagMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> IptagMatchList:
+ """Update an iptag match list entry
+
+ Update an existing iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param iptag_match_list: OK
+ :type iptag_match_list: IptagMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_iptag_match_list_by_id_serialize(
+ id=id,
+ iptag_match_list=iptag_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_iptag_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ iptag_match_list: Annotated[Optional[IptagMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[IptagMatchList]:
+ """Update an iptag match list entry
+
+ Update an existing iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param iptag_match_list: OK
+ :type iptag_match_list: IptagMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_iptag_match_list_by_id_serialize(
+ id=id,
+ iptag_match_list=iptag_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_iptag_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ iptag_match_list: Annotated[Optional[IptagMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an iptag match list entry
+
+ Update an existing iptag match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param iptag_match_list: OK
+ :type iptag_match_list: IptagMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_iptag_match_list_by_id_serialize(
+ id=id,
+ iptag_match_list=iptag_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "IptagMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_iptag_match_list(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single iptag_match_list object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_iptag_match_list(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_iptag_match_list(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_iptag_match_list_by_id_serialize(
+ self,
+ id,
+ iptag_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if iptag_match_list is not None:
+ _body_params = iptag_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/iptag-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/layer2_subinterfaces_api.py b/scm/network_services/api/layer2_subinterfaces_api.py
new file mode 100644
index 00000000..a4557970
--- /dev/null
+++ b/scm/network_services/api/layer2_subinterfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.layer2_subinterfaces import Layer2Subinterfaces
+from scm.network_services.models.layer2_subinterfaces_list_response import Layer2SubinterfacesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class Layer2SubinterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_layer2_subinterfaces(
+ self,
+ layer2_subinterfaces: Annotated[Optional[Layer2Subinterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer2Subinterfaces:
+ """Create a layer 2 subinterface
+
+ Create a new layer 2 subinterface.
+
+ :param layer2_subinterfaces: Created
+ :type layer2_subinterfaces: Layer2Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_layer2_subinterfaces_serialize(
+ layer2_subinterfaces=layer2_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_layer2_subinterfaces_with_http_info(
+ self,
+ layer2_subinterfaces: Annotated[Optional[Layer2Subinterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer2Subinterfaces]:
+ """Create a layer 2 subinterface
+
+ Create a new layer 2 subinterface.
+
+ :param layer2_subinterfaces: Created
+ :type layer2_subinterfaces: Layer2Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_layer2_subinterfaces_serialize(
+ layer2_subinterfaces=layer2_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_layer2_subinterfaces_without_preload_content(
+ self,
+ layer2_subinterfaces: Annotated[Optional[Layer2Subinterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a layer 2 subinterface
+
+ Create a new layer 2 subinterface.
+
+ :param layer2_subinterfaces: Created
+ :type layer2_subinterfaces: Layer2Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_layer2_subinterfaces_serialize(
+ layer2_subinterfaces=layer2_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_layer2_subinterfaces_serialize(
+ self,
+ layer2_subinterfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if layer2_subinterfaces is not None:
+ _body_params = layer2_subinterfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/layer2-subinterfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_layer2_subinterfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a layer 2 subinterface
+
+ Delete a layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_layer2_subinterfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a layer 2 subinterface
+
+ Delete a layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_layer2_subinterfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a layer 2 subinterface
+
+ Delete a layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_layer2_subinterfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/layer2-subinterfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_layer2_subinterfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer2Subinterfaces:
+ """Get a layer 2 subinterface
+
+ Get an existing layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_layer2_subinterfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer2Subinterfaces]:
+ """Get a layer 2 subinterface
+
+ Get an existing layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_layer2_subinterfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a layer 2 subinterface
+
+ Get an existing layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_layer2_subinterfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/layer2-subinterfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_layer2_subinterfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer2SubinterfacesListResponse:
+ """List layer 2 subinterfaces
+
+ Retrieve a list of layer 2 subinterfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_layer2_subinterfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2SubinterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_layer2_subinterfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer2SubinterfacesListResponse]:
+ """List layer 2 subinterfaces
+
+ Retrieve a list of layer 2 subinterfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_layer2_subinterfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2SubinterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_layer2_subinterfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List layer 2 subinterfaces
+
+ Retrieve a list of layer 2 subinterfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_layer2_subinterfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2SubinterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_layer2_subinterfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/layer2-subinterfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_layer2_subinterfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ layer2_subinterfaces: Annotated[Optional[Layer2Subinterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer2Subinterfaces:
+ """Update a layer 2 subinterface
+
+ Update an existing layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param layer2_subinterfaces: OK
+ :type layer2_subinterfaces: Layer2Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ layer2_subinterfaces=layer2_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_layer2_subinterfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ layer2_subinterfaces: Annotated[Optional[Layer2Subinterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer2Subinterfaces]:
+ """Update a layer 2 subinterface
+
+ Update an existing layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param layer2_subinterfaces: OK
+ :type layer2_subinterfaces: Layer2Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ layer2_subinterfaces=layer2_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_layer2_subinterfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ layer2_subinterfaces: Annotated[Optional[Layer2Subinterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a layer 2 subinterface
+
+ Update an existing layer 2 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param layer2_subinterfaces: OK
+ :type layer2_subinterfaces: Layer2Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_layer2_subinterfaces_by_id_serialize(
+ id=id,
+ layer2_subinterfaces=layer2_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer2Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_layer2_subinterfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single layer2_subinterfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_layer2_subinterfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_layer2_subinterfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_layer2_subinterfaces_by_id_serialize(
+ self,
+ id,
+ layer2_subinterfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if layer2_subinterfaces is not None:
+ _body_params = layer2_subinterfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/layer2-subinterfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/layer3_subinterfaces_api.py b/scm/network_services/api/layer3_subinterfaces_api.py
new file mode 100644
index 00000000..5ea50476
--- /dev/null
+++ b/scm/network_services/api/layer3_subinterfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.layer3_subinterfaces import Layer3Subinterfaces
+from scm.network_services.models.layer3_subinterfaces_list_response import Layer3SubinterfacesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class Layer3SubinterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_layer3_subinterfaces(
+ self,
+ layer3_subinterfaces: Annotated[Optional[Layer3Subinterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer3Subinterfaces:
+ """Create a layer 3 subinterface
+
+ Create a new layer 3 subinterface.
+
+ :param layer3_subinterfaces: Created
+ :type layer3_subinterfaces: Layer3Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_layer3_subinterfaces_serialize(
+ layer3_subinterfaces=layer3_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_layer3_subinterfaces_with_http_info(
+ self,
+ layer3_subinterfaces: Annotated[Optional[Layer3Subinterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer3Subinterfaces]:
+ """Create a layer 3 subinterface
+
+ Create a new layer 3 subinterface.
+
+ :param layer3_subinterfaces: Created
+ :type layer3_subinterfaces: Layer3Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_layer3_subinterfaces_serialize(
+ layer3_subinterfaces=layer3_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_layer3_subinterfaces_without_preload_content(
+ self,
+ layer3_subinterfaces: Annotated[Optional[Layer3Subinterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a layer 3 subinterface
+
+ Create a new layer 3 subinterface.
+
+ :param layer3_subinterfaces: Created
+ :type layer3_subinterfaces: Layer3Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_layer3_subinterfaces_serialize(
+ layer3_subinterfaces=layer3_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_layer3_subinterfaces_serialize(
+ self,
+ layer3_subinterfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if layer3_subinterfaces is not None:
+ _body_params = layer3_subinterfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/layer3-subinterfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_layer3_subinterfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a layer 3 subinterface
+
+ Delete a layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_layer3_subinterfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a layer 3 subinterface
+
+ Delete a layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_layer3_subinterfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a layer 3 subinterface
+
+ Delete a layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_layer3_subinterfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/layer3-subinterfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_layer3_subinterfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer3Subinterfaces:
+ """Get a layer 3 subinterface
+
+ Get an existing layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_layer3_subinterfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer3Subinterfaces]:
+ """Get a layer 3 subinterface
+
+ Get an existing layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_layer3_subinterfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a layer 3 subinterface
+
+ Get an existing layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_layer3_subinterfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/layer3-subinterfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_layer3_subinterfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer3SubinterfacesListResponse:
+ """List layer 3 subinterfaces
+
+ Retrieve a list of layer 3 subinterfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_layer3_subinterfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3SubinterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_layer3_subinterfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer3SubinterfacesListResponse]:
+ """List layer 3 subinterfaces
+
+ Retrieve a list of layer 3 subinterfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_layer3_subinterfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3SubinterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_layer3_subinterfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List layer 3 subinterfaces
+
+ Retrieve a list of layer 3 subinterfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_layer3_subinterfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3SubinterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_layer3_subinterfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/layer3-subinterfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_layer3_subinterfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ layer3_subinterfaces: Annotated[Optional[Layer3Subinterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Layer3Subinterfaces:
+ """Update a layer 3 subinterface
+
+ Update an existing layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param layer3_subinterfaces: OK
+ :type layer3_subinterfaces: Layer3Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ layer3_subinterfaces=layer3_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_layer3_subinterfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ layer3_subinterfaces: Annotated[Optional[Layer3Subinterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Layer3Subinterfaces]:
+ """Update a layer 3 subinterface
+
+ Update an existing layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param layer3_subinterfaces: OK
+ :type layer3_subinterfaces: Layer3Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ layer3_subinterfaces=layer3_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_layer3_subinterfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ layer3_subinterfaces: Annotated[Optional[Layer3Subinterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a layer 3 subinterface
+
+ Update an existing layer 3 subinterface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param layer3_subinterfaces: OK
+ :type layer3_subinterfaces: Layer3Subinterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_layer3_subinterfaces_by_id_serialize(
+ id=id,
+ layer3_subinterfaces=layer3_subinterfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Layer3Subinterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_layer3_subinterfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single layer3_subinterfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_layer3_subinterfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_layer3_subinterfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_layer3_subinterfaces_by_id_serialize(
+ self,
+ id,
+ layer3_subinterfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if layer3_subinterfaces is not None:
+ _body_params = layer3_subinterfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/layer3-subinterfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/link_tags_api.py b/scm/network_services/api/link_tags_api.py
new file mode 100644
index 00000000..76d9e966
--- /dev/null
+++ b/scm/network_services/api/link_tags_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.link_tags import LinkTags
+from scm.network_services.models.link_tags_list_response import LinkTagsListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LinkTagsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_link_tags(
+ self,
+ link_tags: Annotated[Optional[LinkTags], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LinkTags:
+ """Create a link tag
+
+ Create a new link tag.
+
+ :param link_tags: Created
+ :type link_tags: LinkTags
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_link_tags_serialize(
+ link_tags=link_tags,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_link_tags_with_http_info(
+ self,
+ link_tags: Annotated[Optional[LinkTags], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LinkTags]:
+ """Create a link tag
+
+ Create a new link tag.
+
+ :param link_tags: Created
+ :type link_tags: LinkTags
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_link_tags_serialize(
+ link_tags=link_tags,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_link_tags_without_preload_content(
+ self,
+ link_tags: Annotated[Optional[LinkTags], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a link tag
+
+ Create a new link tag.
+
+ :param link_tags: Created
+ :type link_tags: LinkTags
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_link_tags_serialize(
+ link_tags=link_tags,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_link_tags_serialize(
+ self,
+ link_tags,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if link_tags is not None:
+ _body_params = link_tags
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/link-tags',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_link_tags_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a link tag
+
+ Delete a link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_link_tags_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_link_tags_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a link tag
+
+ Delete a link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_link_tags_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_link_tags_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a link tag
+
+ Delete a link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_link_tags_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_link_tags_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/link-tags/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_link_tags_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LinkTags:
+ """Get a link tag
+
+ Get an existing link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_link_tags_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_link_tags_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LinkTags]:
+ """Get a link tag
+
+ Get an existing link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_link_tags_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_link_tags_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a link tag
+
+ Get an existing link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_link_tags_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_link_tags_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/link-tags/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_link_tags(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LinkTagsListResponse:
+ """List link tags
+
+ Retrieve a list of link tags.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_link_tags_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTagsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_link_tags_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LinkTagsListResponse]:
+ """List link tags
+
+ Retrieve a list of link tags.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_link_tags_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTagsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_link_tags_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List link tags
+
+ Retrieve a list of link tags.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_link_tags_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTagsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_link_tags_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/link-tags',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_link_tags_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ link_tags: Annotated[Optional[LinkTags], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LinkTags:
+ """Update a link tag
+
+ Update an existing link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param link_tags: OK
+ :type link_tags: LinkTags
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_link_tags_by_id_serialize(
+ id=id,
+ link_tags=link_tags,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_link_tags_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ link_tags: Annotated[Optional[LinkTags], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LinkTags]:
+ """Update a link tag
+
+ Update an existing link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param link_tags: OK
+ :type link_tags: LinkTags
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_link_tags_by_id_serialize(
+ id=id,
+ link_tags=link_tags,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_link_tags_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ link_tags: Annotated[Optional[LinkTags], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a link tag
+
+ Update an existing link tag.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param link_tags: OK
+ :type link_tags: LinkTags
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_link_tags_by_id_serialize(
+ id=id,
+ link_tags=link_tags,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LinkTags",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_link_tags(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single link_tags object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_link_tags(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_link_tags(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_link_tags_by_id_serialize(
+ self,
+ id,
+ link_tags,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if link_tags is not None:
+ _body_params = link_tags
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/link-tags/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/lldp_profiles_api.py b/scm/network_services/api/lldp_profiles_api.py
new file mode 100644
index 00000000..a68e4758
--- /dev/null
+++ b/scm/network_services/api/lldp_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.lldp_profiles_list_response import LLDPProfilesListResponse
+from scm.network_services.models.lldp_profiles import LldpProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LLDPProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_lldp_profiles(
+ self,
+ lldp_profiles: Annotated[Optional[LldpProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LldpProfiles:
+ """Create an LLDP profile
+
+ Create a new LLDP profile.
+
+ :param lldp_profiles: Created
+ :type lldp_profiles: LldpProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_lldp_profiles_serialize(
+ lldp_profiles=lldp_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_lldp_profiles_with_http_info(
+ self,
+ lldp_profiles: Annotated[Optional[LldpProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LldpProfiles]:
+ """Create an LLDP profile
+
+ Create a new LLDP profile.
+
+ :param lldp_profiles: Created
+ :type lldp_profiles: LldpProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_lldp_profiles_serialize(
+ lldp_profiles=lldp_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_lldp_profiles_without_preload_content(
+ self,
+ lldp_profiles: Annotated[Optional[LldpProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an LLDP profile
+
+ Create a new LLDP profile.
+
+ :param lldp_profiles: Created
+ :type lldp_profiles: LldpProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_lldp_profiles_serialize(
+ lldp_profiles=lldp_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_lldp_profiles_serialize(
+ self,
+ lldp_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if lldp_profiles is not None:
+ _body_params = lldp_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/lldp-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_lldp_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an LLDP profile
+
+ Delete an LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_lldp_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_lldp_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an LLDP profile
+
+ Delete an LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_lldp_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_lldp_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an LLDP profile
+
+ Delete an LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_lldp_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_lldp_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/lldp-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_lldp_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LldpProfiles:
+ """Get an LLDP profile
+
+ Get an existing LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_lldp_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_lldp_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LldpProfiles]:
+ """Get an LLDP profile
+
+ Get an existing LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_lldp_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_lldp_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an LLDP profile
+
+ Get an existing LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_lldp_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_lldp_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/lldp-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_lldp_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LLDPProfilesListResponse:
+ """List LLDP profiles
+
+ Retrieve a list of LLDP profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_lldp_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LLDPProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_lldp_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LLDPProfilesListResponse]:
+ """List LLDP profiles
+
+ Retrieve a list of LLDP profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_lldp_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LLDPProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_lldp_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List LLDP profiles
+
+ Retrieve a list of LLDP profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_lldp_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LLDPProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_lldp_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/lldp-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_lldp_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ lldp_profiles: Annotated[Optional[LldpProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LldpProfiles:
+ """Update an LLDP profile
+
+ Update an existing LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param lldp_profiles: OK
+ :type lldp_profiles: LldpProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_lldp_profiles_by_id_serialize(
+ id=id,
+ lldp_profiles=lldp_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_lldp_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ lldp_profiles: Annotated[Optional[LldpProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LldpProfiles]:
+ """Update an LLDP profile
+
+ Update an existing LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param lldp_profiles: OK
+ :type lldp_profiles: LldpProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_lldp_profiles_by_id_serialize(
+ id=id,
+ lldp_profiles=lldp_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_lldp_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ lldp_profiles: Annotated[Optional[LldpProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an LLDP profile
+
+ Update an existing LLDP profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param lldp_profiles: OK
+ :type lldp_profiles: LldpProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_lldp_profiles_by_id_serialize(
+ id=id,
+ lldp_profiles=lldp_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LldpProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_lldp_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single lldp_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_lldp_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_lldp_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_lldp_profiles_by_id_serialize(
+ self,
+ id,
+ lldp_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if lldp_profiles is not None:
+ _body_params = lldp_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/lldp-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/logical_routers_api.py b/scm/network_services/api/logical_routers_api.py
new file mode 100644
index 00000000..ee087d9a
--- /dev/null
+++ b/scm/network_services/api/logical_routers_api.py
@@ -0,0 +1,1636 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictBool, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.logical_routers import LogicalRouters
+from scm.network_services.models.logical_routers_list_response import LogicalRoutersListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LogicalRoutersApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_logical_routers(
+ self,
+ logical_routers: Annotated[Optional[LogicalRouters], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LogicalRouters:
+ """Create a logical router
+
+ Create a new logical router.
+
+ :param logical_routers: Created
+ :type logical_routers: LogicalRouters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_logical_routers_serialize(
+ logical_routers=logical_routers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_logical_routers_with_http_info(
+ self,
+ logical_routers: Annotated[Optional[LogicalRouters], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LogicalRouters]:
+ """Create a logical router
+
+ Create a new logical router.
+
+ :param logical_routers: Created
+ :type logical_routers: LogicalRouters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_logical_routers_serialize(
+ logical_routers=logical_routers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_logical_routers_without_preload_content(
+ self,
+ logical_routers: Annotated[Optional[LogicalRouters], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a logical router
+
+ Create a new logical router.
+
+ :param logical_routers: Created
+ :type logical_routers: LogicalRouters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_logical_routers_serialize(
+ logical_routers=logical_routers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_logical_routers_serialize(
+ self,
+ logical_routers,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if logical_routers is not None:
+ _body_params = logical_routers
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/logical-routers',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_logical_routers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a logical router
+
+ Delete a logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_logical_routers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_logical_routers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a logical router
+
+ Delete a logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_logical_routers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_logical_routers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a logical router
+
+ Delete a logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_logical_routers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_logical_routers_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/logical-routers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_logical_routers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LogicalRouters:
+ """Get a logical router
+
+ Get an existing logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_logical_routers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_logical_routers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LogicalRouters]:
+ """Get a logical router
+
+ Get an existing logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_logical_routers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_logical_routers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a logical router
+
+ Get an existing logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_logical_routers_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_logical_routers_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/logical-routers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_logical_routers(
+ self,
+ pagination: Annotated[Optional[StrictBool], Field(description="The parameter to mention if the response should be paginated. By default, its set to false")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LogicalRoutersListResponse:
+ """List logical routers
+
+ Retrieve a list of logical routers.
+
+ :param pagination: The parameter to mention if the response should be paginated. By default, its set to false
+ :type pagination: bool
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_logical_routers_serialize(
+ pagination=pagination,
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRoutersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_logical_routers_with_http_info(
+ self,
+ pagination: Annotated[Optional[StrictBool], Field(description="The parameter to mention if the response should be paginated. By default, its set to false")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LogicalRoutersListResponse]:
+ """List logical routers
+
+ Retrieve a list of logical routers.
+
+ :param pagination: The parameter to mention if the response should be paginated. By default, its set to false
+ :type pagination: bool
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_logical_routers_serialize(
+ pagination=pagination,
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRoutersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_logical_routers_without_preload_content(
+ self,
+ pagination: Annotated[Optional[StrictBool], Field(description="The parameter to mention if the response should be paginated. By default, its set to false")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List logical routers
+
+ Retrieve a list of logical routers.
+
+ :param pagination: The parameter to mention if the response should be paginated. By default, its set to false
+ :type pagination: bool
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_logical_routers_serialize(
+ pagination=pagination,
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRoutersListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_logical_routers_serialize(
+ self,
+ pagination,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if pagination is not None:
+
+ _query_params.append(('pagination', pagination))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/logical-routers',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_logical_routers_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ logical_routers: Annotated[Optional[LogicalRouters], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LogicalRouters:
+ """Update a logical router
+
+ Update an existing logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param logical_routers: OK
+ :type logical_routers: LogicalRouters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_logical_routers_by_id_serialize(
+ id=id,
+ logical_routers=logical_routers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_logical_routers_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ logical_routers: Annotated[Optional[LogicalRouters], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LogicalRouters]:
+ """Update a logical router
+
+ Update an existing logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param logical_routers: OK
+ :type logical_routers: LogicalRouters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_logical_routers_by_id_serialize(
+ id=id,
+ logical_routers=logical_routers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_logical_routers_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ logical_routers: Annotated[Optional[LogicalRouters], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a logical router
+
+ Update an existing logical router.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param logical_routers: OK
+ :type logical_routers: LogicalRouters
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_logical_routers_by_id_serialize(
+ id=id,
+ logical_routers=logical_routers,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LogicalRouters",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_logical_routers(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single logical_routers object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_logical_routers(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_logical_routers(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_logical_routers_by_id_serialize(
+ self,
+ id,
+ logical_routers,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if logical_routers is not None:
+ _body_params = logical_routers
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/logical-routers/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/loopback_interfaces_api.py b/scm/network_services/api/loopback_interfaces_api.py
new file mode 100644
index 00000000..2d035941
--- /dev/null
+++ b/scm/network_services/api/loopback_interfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.loopback_interfaces import LoopbackInterfaces
+from scm.network_services.models.loopback_interfaces_list_response import LoopbackInterfacesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class LoopbackInterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_loopback_interfaces(
+ self,
+ loopback_interfaces: Annotated[Optional[LoopbackInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LoopbackInterfaces:
+ """Create a loopback interface
+
+ Create a new loopback interface.
+
+ :param loopback_interfaces: Created
+ :type loopback_interfaces: LoopbackInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_loopback_interfaces_serialize(
+ loopback_interfaces=loopback_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_loopback_interfaces_with_http_info(
+ self,
+ loopback_interfaces: Annotated[Optional[LoopbackInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LoopbackInterfaces]:
+ """Create a loopback interface
+
+ Create a new loopback interface.
+
+ :param loopback_interfaces: Created
+ :type loopback_interfaces: LoopbackInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_loopback_interfaces_serialize(
+ loopback_interfaces=loopback_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_loopback_interfaces_without_preload_content(
+ self,
+ loopback_interfaces: Annotated[Optional[LoopbackInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a loopback interface
+
+ Create a new loopback interface.
+
+ :param loopback_interfaces: Created
+ :type loopback_interfaces: LoopbackInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_loopback_interfaces_serialize(
+ loopback_interfaces=loopback_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_loopback_interfaces_serialize(
+ self,
+ loopback_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if loopback_interfaces is not None:
+ _body_params = loopback_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/loopback-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_loopback_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a loopback interface
+
+ Delete a loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_loopback_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_loopback_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a loopback interface
+
+ Delete a loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_loopback_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_loopback_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a loopback interface
+
+ Delete a loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_loopback_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_loopback_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/loopback-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_loopback_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LoopbackInterfaces:
+ """Get a loopback interface
+
+ Get an existing loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_loopback_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_loopback_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LoopbackInterfaces]:
+ """Get a loopback interface
+
+ Get an existing loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_loopback_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_loopback_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a loopback interface
+
+ Get an existing loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_loopback_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_loopback_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/loopback-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_loopback_interfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LoopbackInterfacesListResponse:
+ """List loopback interfaces
+
+ Retrieve a list of loopback interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_loopback_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_loopback_interfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LoopbackInterfacesListResponse]:
+ """List loopback interfaces
+
+ Retrieve a list of loopback interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_loopback_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_loopback_interfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List loopback interfaces
+
+ Retrieve a list of loopback interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_loopback_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_loopback_interfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/loopback-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_loopback_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ loopback_interfaces: Annotated[Optional[LoopbackInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LoopbackInterfaces:
+ """Update a loopback interface
+
+ Update an existing loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param loopback_interfaces: OK
+ :type loopback_interfaces: LoopbackInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_loopback_interfaces_by_id_serialize(
+ id=id,
+ loopback_interfaces=loopback_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_loopback_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ loopback_interfaces: Annotated[Optional[LoopbackInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LoopbackInterfaces]:
+ """Update a loopback interface
+
+ Update an existing loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param loopback_interfaces: OK
+ :type loopback_interfaces: LoopbackInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_loopback_interfaces_by_id_serialize(
+ id=id,
+ loopback_interfaces=loopback_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_loopback_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ loopback_interfaces: Annotated[Optional[LoopbackInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a loopback interface
+
+ Update an existing loopback interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param loopback_interfaces: OK
+ :type loopback_interfaces: LoopbackInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_loopback_interfaces_by_id_serialize(
+ id=id,
+ loopback_interfaces=loopback_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LoopbackInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_loopback_interfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single loopback_interfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_loopback_interfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_loopback_interfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_loopback_interfaces_by_id_serialize(
+ self,
+ id,
+ loopback_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if loopback_interfaces is not None:
+ _body_params = loopback_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/loopback-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/nat_rules_api.py b/scm/network_services/api/nat_rules_api.py
new file mode 100644
index 00000000..68c7fd04
--- /dev/null
+++ b/scm/network_services/api/nat_rules_api.py
@@ -0,0 +1,1670 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.nat_rules import NatRules
+from scm.network_services.models.nat_rules_list_response import NatRulesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class NATRulesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_nat_rules(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ nat_rules: Annotated[Optional[NatRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> NatRules:
+ """Create a NAT rule
+
+ Create a new NAT rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param nat_rules: Created
+ :type nat_rules: NatRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_nat_rules_serialize(
+ position=position,
+ nat_rules=nat_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_nat_rules_with_http_info(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ nat_rules: Annotated[Optional[NatRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[NatRules]:
+ """Create a NAT rule
+
+ Create a new NAT rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param nat_rules: Created
+ :type nat_rules: NatRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_nat_rules_serialize(
+ position=position,
+ nat_rules=nat_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_nat_rules_without_preload_content(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ nat_rules: Annotated[Optional[NatRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a NAT rule
+
+ Create a new NAT rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param nat_rules: Created
+ :type nat_rules: NatRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_nat_rules_serialize(
+ position=position,
+ nat_rules=nat_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_nat_rules_serialize(
+ self,
+ position,
+ nat_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if nat_rules is not None:
+ _body_params = nat_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/nat-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_nat_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a NAT rule
+
+ Delete a NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_nat_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_nat_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a NAT rule
+
+ Delete a NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_nat_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_nat_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a NAT rule
+
+ Delete a NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_nat_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_nat_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/nat-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_nat_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> NatRules:
+ """Get a NAT rule
+
+ Get an existing NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_nat_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_nat_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[NatRules]:
+ """Get a NAT rule
+
+ Get an existing NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_nat_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_nat_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a NAT rule
+
+ Get an existing NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_nat_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_nat_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/nat-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_nat_rules(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> NatRulesListResponse:
+ """List NAT rules
+
+ Retrieve a list of NAT rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_nat_rules_serialize(
+ position=position,
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_nat_rules_with_http_info(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[NatRulesListResponse]:
+ """List NAT rules
+
+ Retrieve a list of NAT rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_nat_rules_serialize(
+ position=position,
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_nat_rules_without_preload_content(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List NAT rules
+
+ Retrieve a list of NAT rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_nat_rules_serialize(
+ position=position,
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_nat_rules_serialize(
+ self,
+ position,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/nat-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_nat_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ nat_rules: Annotated[Optional[NatRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> NatRules:
+ """Update a NAT rule
+
+ Update an existing NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param nat_rules: OK
+ :type nat_rules: NatRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_nat_rules_by_id_serialize(
+ id=id,
+ position=position,
+ nat_rules=nat_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_nat_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ nat_rules: Annotated[Optional[NatRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[NatRules]:
+ """Update a NAT rule
+
+ Update an existing NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param nat_rules: OK
+ :type nat_rules: NatRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_nat_rules_by_id_serialize(
+ id=id,
+ position=position,
+ nat_rules=nat_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_nat_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ nat_rules: Annotated[Optional[NatRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a NAT rule
+
+ Update an existing NAT rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param nat_rules: OK
+ :type nat_rules: NatRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_nat_rules_by_id_serialize(
+ id=id,
+ position=position,
+ nat_rules=nat_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "NatRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_nat_rules(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single nat_rules object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_nat_rules(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_nat_rules(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_nat_rules_by_id_serialize(
+ self,
+ id,
+ position,
+ nat_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if nat_rules is not None:
+ _body_params = nat_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/nat-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/ospf_authentication_profiles_api.py b/scm/network_services/api/ospf_authentication_profiles_api.py
new file mode 100644
index 00000000..2d6e86db
--- /dev/null
+++ b/scm/network_services/api/ospf_authentication_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.ospf_authentication_profiles_list_response import OSPFAuthenticationProfilesListResponse
+from scm.network_services.models.ospf_auth_profiles import OspfAuthProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class OSPFAuthenticationProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_ospf_authentication_profiles(
+ self,
+ ospf_auth_profiles: Annotated[Optional[OspfAuthProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> OspfAuthProfiles:
+ """Create an OSPF authentication profile
+
+ Create a new OSPF authentication profile.
+
+ :param ospf_auth_profiles: Created
+ :type ospf_auth_profiles: OspfAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ospf_authentication_profiles_serialize(
+ ospf_auth_profiles=ospf_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_ospf_authentication_profiles_with_http_info(
+ self,
+ ospf_auth_profiles: Annotated[Optional[OspfAuthProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[OspfAuthProfiles]:
+ """Create an OSPF authentication profile
+
+ Create a new OSPF authentication profile.
+
+ :param ospf_auth_profiles: Created
+ :type ospf_auth_profiles: OspfAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ospf_authentication_profiles_serialize(
+ ospf_auth_profiles=ospf_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_ospf_authentication_profiles_without_preload_content(
+ self,
+ ospf_auth_profiles: Annotated[Optional[OspfAuthProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an OSPF authentication profile
+
+ Create a new OSPF authentication profile.
+
+ :param ospf_auth_profiles: Created
+ :type ospf_auth_profiles: OspfAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_ospf_authentication_profiles_serialize(
+ ospf_auth_profiles=ospf_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_ospf_authentication_profiles_serialize(
+ self,
+ ospf_auth_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ospf_auth_profiles is not None:
+ _body_params = ospf_auth_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/ospf-auth-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ospf_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an OSPF authentication profile
+
+ Delete an OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ospf_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an OSPF authentication profile
+
+ Delete an OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_ospf_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an OSPF authentication profile
+
+ Delete an OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_ospf_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/ospf-auth-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_ospf_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> OspfAuthProfiles:
+ """Get an OSPF authentication profile
+
+ Get an existing OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_ospf_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[OspfAuthProfiles]:
+ """Get an OSPF authentication profile
+
+ Get an existing OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_ospf_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an OSPF authentication profile
+
+ Get an existing OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_ospf_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ospf-auth-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_ospf_authentication_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> OSPFAuthenticationProfilesListResponse:
+ """List OSPF authentication profiles
+
+ Retrieve a list of OSPF authentication profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ospf_authentication_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OSPFAuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_ospf_authentication_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[OSPFAuthenticationProfilesListResponse]:
+ """List OSPF authentication profiles
+
+ Retrieve a list of OSPF authentication profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ospf_authentication_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OSPFAuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_ospf_authentication_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List OSPF authentication profiles
+
+ Retrieve a list of OSPF authentication profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_ospf_authentication_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OSPFAuthenticationProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_ospf_authentication_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/ospf-auth-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_ospf_authentication_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ospf_auth_profiles: Annotated[Optional[OspfAuthProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> OspfAuthProfiles:
+ """Update an OSPF authentication profile
+
+ Update an existing OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ospf_auth_profiles: OK
+ :type ospf_auth_profiles: OspfAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ ospf_auth_profiles=ospf_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_ospf_authentication_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ospf_auth_profiles: Annotated[Optional[OspfAuthProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[OspfAuthProfiles]:
+ """Update an OSPF authentication profile
+
+ Update an existing OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ospf_auth_profiles: OK
+ :type ospf_auth_profiles: OspfAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ ospf_auth_profiles=ospf_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_ospf_authentication_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ ospf_auth_profiles: Annotated[Optional[OspfAuthProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an OSPF authentication profile
+
+ Update an existing OSPF authentication profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param ospf_auth_profiles: OK
+ :type ospf_auth_profiles: OspfAuthProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_ospf_authentication_profiles_by_id_serialize(
+ id=id,
+ ospf_auth_profiles=ospf_auth_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "OspfAuthProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_ospf_authentication_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single ospf_authentication_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_ospf_authentication_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_ospf_authentication_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_ospf_authentication_profiles_by_id_serialize(
+ self,
+ id,
+ ospf_auth_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if ospf_auth_profiles is not None:
+ _body_params = ospf_auth_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/ospf-auth-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/pbf_rules_api.py b/scm/network_services/api/pbf_rules_api.py
new file mode 100644
index 00000000..db493279
--- /dev/null
+++ b/scm/network_services/api/pbf_rules_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.pbf_rules_list_response import PBFRulesListResponse
+from scm.network_services.models.pbf_rules import PbfRules
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class PBFRulesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_pbf_rules(
+ self,
+ pbf_rules: Annotated[Optional[PbfRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> PbfRules:
+ """Create a PBF rule
+
+ Create a new PBF rule.
+
+ :param pbf_rules: Created
+ :type pbf_rules: PbfRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_pbf_rules_serialize(
+ pbf_rules=pbf_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_pbf_rules_with_http_info(
+ self,
+ pbf_rules: Annotated[Optional[PbfRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[PbfRules]:
+ """Create a PBF rule
+
+ Create a new PBF rule.
+
+ :param pbf_rules: Created
+ :type pbf_rules: PbfRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_pbf_rules_serialize(
+ pbf_rules=pbf_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_pbf_rules_without_preload_content(
+ self,
+ pbf_rules: Annotated[Optional[PbfRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a PBF rule
+
+ Create a new PBF rule.
+
+ :param pbf_rules: Created
+ :type pbf_rules: PbfRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_pbf_rules_serialize(
+ pbf_rules=pbf_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_pbf_rules_serialize(
+ self,
+ pbf_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if pbf_rules is not None:
+ _body_params = pbf_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/pbf-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_pbf_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a PBF rule
+
+ Delete a PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_pbf_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_pbf_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a PBF rule
+
+ Delete a PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_pbf_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_pbf_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a PBF rule
+
+ Delete a PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_pbf_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_pbf_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/pbf-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_pbf_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> PbfRules:
+ """Get a PBF rule
+
+ Get an existing PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_pbf_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_pbf_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[PbfRules]:
+ """Get a PBF rule
+
+ Get an existing PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_pbf_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_pbf_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a PBF rule
+
+ Get an existing PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_pbf_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_pbf_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/pbf-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_pbf_rules(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> PBFRulesListResponse:
+ """List PBF rules
+
+ Retrieve a list of PBF rules.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_pbf_rules_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PBFRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_pbf_rules_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[PBFRulesListResponse]:
+ """List PBF rules
+
+ Retrieve a list of PBF rules.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_pbf_rules_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PBFRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_pbf_rules_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List PBF rules
+
+ Retrieve a list of PBF rules.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_pbf_rules_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PBFRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_pbf_rules_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/pbf-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_pbf_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ pbf_rules: Annotated[Optional[PbfRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> PbfRules:
+ """Update a PBF rule
+
+ Update an existing PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param pbf_rules: OK
+ :type pbf_rules: PbfRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_pbf_rules_by_id_serialize(
+ id=id,
+ pbf_rules=pbf_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_pbf_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ pbf_rules: Annotated[Optional[PbfRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[PbfRules]:
+ """Update a PBF rule
+
+ Update an existing PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param pbf_rules: OK
+ :type pbf_rules: PbfRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_pbf_rules_by_id_serialize(
+ id=id,
+ pbf_rules=pbf_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_pbf_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ pbf_rules: Annotated[Optional[PbfRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a PBF rule
+
+ Update an existing PBF rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param pbf_rules: OK
+ :type pbf_rules: PbfRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_pbf_rules_by_id_serialize(
+ id=id,
+ pbf_rules=pbf_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "PbfRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_pbf_rules(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single pbf_rules object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_pbf_rules(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_pbf_rules(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_pbf_rules_by_id_serialize(
+ self,
+ id,
+ pbf_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if pbf_rules is not None:
+ _body_params = pbf_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/pbf-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/qos_profiles_api.py b/scm/network_services/api/qos_profiles_api.py
new file mode 100644
index 00000000..128b97b5
--- /dev/null
+++ b/scm/network_services/api/qos_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.qos_profiles_list_response import QoSProfilesListResponse
+from scm.network_services.models.qos_profiles import QosProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class QoSProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_qo_s_profiles(
+ self,
+ qos_profiles: Annotated[Optional[QosProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QosProfiles:
+ """Create a QoS profile
+
+ Create a new QoS profile.
+
+ :param qos_profiles: Created
+ :type qos_profiles: QosProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_qo_s_profiles_serialize(
+ qos_profiles=qos_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_qo_s_profiles_with_http_info(
+ self,
+ qos_profiles: Annotated[Optional[QosProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QosProfiles]:
+ """Create a QoS profile
+
+ Create a new QoS profile.
+
+ :param qos_profiles: Created
+ :type qos_profiles: QosProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_qo_s_profiles_serialize(
+ qos_profiles=qos_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_qo_s_profiles_without_preload_content(
+ self,
+ qos_profiles: Annotated[Optional[QosProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a QoS profile
+
+ Create a new QoS profile.
+
+ :param qos_profiles: Created
+ :type qos_profiles: QosProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_qo_s_profiles_serialize(
+ qos_profiles=qos_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_qo_s_profiles_serialize(
+ self,
+ qos_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if qos_profiles is not None:
+ _body_params = qos_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/qos-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_qo_s_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a QoS profile
+
+ Delete a QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_qo_s_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_qo_s_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a QoS profile
+
+ Delete a QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_qo_s_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_qo_s_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a QoS profile
+
+ Delete a QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_qo_s_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_qo_s_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/qos-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_qo_s_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QosProfiles:
+ """Get a QoS profile
+
+ Get an existing QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_qo_s_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_qo_s_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QosProfiles]:
+ """Get a QoS profile
+
+ Get an existing QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_qo_s_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_qo_s_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a QoS profile
+
+ Get an existing QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_qo_s_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_qo_s_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/qos-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_qo_s_profiles(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QoSProfilesListResponse:
+ """List QoS profiles
+
+ Retrieve a list of QoS profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_qo_s_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QoSProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_qo_s_profiles_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QoSProfilesListResponse]:
+ """List QoS profiles
+
+ Retrieve a list of QoS profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_qo_s_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QoSProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_qo_s_profiles_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List QoS profiles
+
+ Retrieve a list of QoS profiles.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_qo_s_profiles_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ limit=limit,
+ offset=offset,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QoSProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_qo_s_profiles_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ limit,
+ offset,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/qos-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_qo_s_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ qos_profiles: Annotated[Optional[QosProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QosProfiles:
+ """Update a QoS profile
+
+ Update an existing QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param qos_profiles: OK
+ :type qos_profiles: QosProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_qo_s_profiles_by_id_serialize(
+ id=id,
+ qos_profiles=qos_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_qo_s_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ qos_profiles: Annotated[Optional[QosProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QosProfiles]:
+ """Update a QoS profile
+
+ Update an existing QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param qos_profiles: OK
+ :type qos_profiles: QosProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_qo_s_profiles_by_id_serialize(
+ id=id,
+ qos_profiles=qos_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_qo_s_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ qos_profiles: Annotated[Optional[QosProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a QoS profile
+
+ Update an existing QoS profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param qos_profiles: OK
+ :type qos_profiles: QosProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_qo_s_profiles_by_id_serialize(
+ id=id,
+ qos_profiles=qos_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_qos_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single qos_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_qos_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_qo_s_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_qo_s_profiles_by_id_serialize(
+ self,
+ id,
+ qos_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if qos_profiles is not None:
+ _body_params = qos_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/qos-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/qos_rules_api.py b/scm/network_services/api/qos_rules_api.py
new file mode 100644
index 00000000..09e493ce
--- /dev/null
+++ b/scm/network_services/api/qos_rules_api.py
@@ -0,0 +1,1958 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr, field_validator
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.qos_policy_rules_list_response import QoSPolicyRulesListResponse
+from scm.network_services.models.qos_policy_rules import QosPolicyRules
+from scm.network_services.models.rule_based_move import RuleBasedMove
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class QoSRulesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_qo_s_policy_rules(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ qos_policy_rules: Annotated[Optional[QosPolicyRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QosPolicyRules:
+ """Create a QoS policy rule
+
+ Create a new QoS policy rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param qos_policy_rules: Created
+ :type qos_policy_rules: QosPolicyRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_qo_s_policy_rules_serialize(
+ position=position,
+ qos_policy_rules=qos_policy_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_qo_s_policy_rules_with_http_info(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ qos_policy_rules: Annotated[Optional[QosPolicyRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QosPolicyRules]:
+ """Create a QoS policy rule
+
+ Create a new QoS policy rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param qos_policy_rules: Created
+ :type qos_policy_rules: QosPolicyRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_qo_s_policy_rules_serialize(
+ position=position,
+ qos_policy_rules=qos_policy_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_qo_s_policy_rules_without_preload_content(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ qos_policy_rules: Annotated[Optional[QosPolicyRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a QoS policy rule
+
+ Create a new QoS policy rule.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param qos_policy_rules: Created
+ :type qos_policy_rules: QosPolicyRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_qo_s_policy_rules_serialize(
+ position=position,
+ qos_policy_rules=qos_policy_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_qo_s_policy_rules_serialize(
+ self,
+ position,
+ qos_policy_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if qos_policy_rules is not None:
+ _body_params = qos_policy_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/qos-policy-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_qo_s_policy_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a QoS policy rule
+
+ Delete a Qos policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_qo_s_policy_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a QoS policy rule
+
+ Delete a Qos policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_qo_s_policy_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a QoS policy rule
+
+ Delete a Qos policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_qo_s_policy_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/qos-policy-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_qo_s_policy_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QosPolicyRules:
+ """Get a QoS policy rule
+
+ Get an existing QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_qo_s_policy_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QosPolicyRules]:
+ """Get a QoS policy rule
+
+ Get an existing QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_qo_s_policy_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a QoS policy rule
+
+ Get an existing QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_qo_s_policy_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/qos-policy-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_qo_s_policy_rules(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QoSPolicyRulesListResponse:
+ """List QoS policy rules
+
+ Retrieve a list of QoS policy rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_qo_s_policy_rules_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QoSPolicyRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_qo_s_policy_rules_with_http_info(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QoSPolicyRulesListResponse]:
+ """List QoS policy rules
+
+ Retrieve a list of QoS policy rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_qo_s_policy_rules_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QoSPolicyRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_qo_s_policy_rules_without_preload_content(
+ self,
+ position: Annotated[StrictStr, Field(description="The relative position of the rule")],
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List QoS policy rules
+
+ Retrieve a list of QoS policy rules.
+
+ :param position: The relative position of the rule (required)
+ :type position: str
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_qo_s_policy_rules_serialize(
+ position=position,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QoSPolicyRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_qo_s_policy_rules_serialize(
+ self,
+ position,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if position is not None:
+
+ _query_params.append(('position', position))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/qos-policy-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def move_qo_s_policy_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ rule_based_move: Annotated[Optional[RuleBasedMove], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Move a QoS policy rule
+
+ Move a QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param rule_based_move: OK
+ :type rule_based_move: RuleBasedMove
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._move_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ rule_based_move=rule_based_move,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def move_qo_s_policy_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ rule_based_move: Annotated[Optional[RuleBasedMove], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Move a QoS policy rule
+
+ Move a QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param rule_based_move: OK
+ :type rule_based_move: RuleBasedMove
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._move_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ rule_based_move=rule_based_move,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def move_qo_s_policy_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ rule_based_move: Annotated[Optional[RuleBasedMove], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Move a QoS policy rule
+
+ Move a QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param rule_based_move: OK
+ :type rule_based_move: RuleBasedMove
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._move_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ rule_based_move=rule_based_move,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _move_qo_s_policy_rules_by_id_serialize(
+ self,
+ id,
+ rule_based_move,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if rule_based_move is not None:
+ _body_params = rule_based_move
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/qos-policy-rules/{id}:move',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_qo_s_policy_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ qos_policy_rules: Annotated[Optional[QosPolicyRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> QosPolicyRules:
+ """Update a QoS policy rule
+
+ Update an existing QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param qos_policy_rules: OK
+ :type qos_policy_rules: QosPolicyRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ qos_policy_rules=qos_policy_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_qo_s_policy_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ qos_policy_rules: Annotated[Optional[QosPolicyRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[QosPolicyRules]:
+ """Update a QoS policy rule
+
+ Update an existing QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param qos_policy_rules: OK
+ :type qos_policy_rules: QosPolicyRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ qos_policy_rules=qos_policy_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_qo_s_policy_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ qos_policy_rules: Annotated[Optional[QosPolicyRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a QoS policy rule
+
+ Update an existing QoS policy rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param qos_policy_rules: OK
+ :type qos_policy_rules: QosPolicyRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_qo_s_policy_rules_by_id_serialize(
+ id=id,
+ qos_policy_rules=qos_policy_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "QosPolicyRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_qos_rules(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single qos_rules object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_qos_rules(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_qo_s_policy_rules(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_qo_s_policy_rules_by_id_serialize(
+ self,
+ id,
+ qos_policy_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if qos_policy_rules is not None:
+ _body_params = qos_policy_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/qos-policy-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/remote_networks_license_api.py b/scm/network_services/api/remote_networks_license_api.py
new file mode 100644
index 00000000..2314d0a3
--- /dev/null
+++ b/scm/network_services/api/remote_networks_license_api.py
@@ -0,0 +1,306 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from scm.network_services.models.license_result import LicenseResult
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class RemoteNetworksLicenseApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def get_remote_networks_license_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> LicenseResult:
+ """Get Remote Networks License Info
+
+ Returns operational license model and site license counts.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_remote_networks_license_info_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LicenseResult",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ '500': "GetRemoteNetworksLicenseInfo500Response",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_remote_networks_license_info_with_http_info(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[LicenseResult]:
+ """Get Remote Networks License Info
+
+ Returns operational license model and site license counts.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_remote_networks_license_info_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LicenseResult",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ '500': "GetRemoteNetworksLicenseInfo500Response",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_remote_networks_license_info_without_preload_content(
+ self,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get Remote Networks License Info
+
+ Returns operational license model and site license counts.
+
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_remote_networks_license_info_serialize(
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "LicenseResult",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ '500': "GetRemoteNetworksLicenseInfo500Response",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_remote_networks_license_info_serialize(
+ self,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/remote-networks-license-info',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/route_access_lists_api.py b/scm/network_services/api/route_access_lists_api.py
new file mode 100644
index 00000000..5f6996b5
--- /dev/null
+++ b/scm/network_services/api/route_access_lists_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.route_access_lists import RouteAccessLists
+from scm.network_services.models.route_access_lists_list_response import RouteAccessListsListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class RouteAccessListsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_access_lists(
+ self,
+ route_access_lists: Annotated[Optional[RouteAccessLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteAccessLists:
+ """Create a route access list
+
+ Create a new PBF rule.
+
+ :param route_access_lists: Created
+ :type route_access_lists: RouteAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_access_lists_serialize(
+ route_access_lists=route_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_access_lists_with_http_info(
+ self,
+ route_access_lists: Annotated[Optional[RouteAccessLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteAccessLists]:
+ """Create a route access list
+
+ Create a new PBF rule.
+
+ :param route_access_lists: Created
+ :type route_access_lists: RouteAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_access_lists_serialize(
+ route_access_lists=route_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_access_lists_without_preload_content(
+ self,
+ route_access_lists: Annotated[Optional[RouteAccessLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a route access list
+
+ Create a new PBF rule.
+
+ :param route_access_lists: Created
+ :type route_access_lists: RouteAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_access_lists_serialize(
+ route_access_lists=route_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_route_access_lists_serialize(
+ self,
+ route_access_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_access_lists is not None:
+ _body_params = route_access_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/route-access-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_access_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a route access list
+
+ Delete a route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_access_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a route access list
+
+ Delete a route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_access_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a route access list
+
+ Delete a route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_route_access_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/route-access-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_access_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteAccessLists:
+ """Get a route access list
+
+ Get an existing route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_access_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteAccessLists]:
+ """Get a route access list
+
+ Get an existing route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_access_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a route access list
+
+ Get an existing route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_route_access_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-access-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_access_lists(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteAccessListsListResponse:
+ """List route access lists
+
+ Retrieve a list of route access lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_access_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_access_lists_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteAccessListsListResponse]:
+ """List route access lists
+
+ Retrieve a list of route access lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_access_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_access_lists_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List route access lists
+
+ Retrieve a list of route access lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_access_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_route_access_lists_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-access-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_access_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_access_lists: Annotated[Optional[RouteAccessLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteAccessLists:
+ """Update a route access list
+
+ Update an existing route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_access_lists: OK
+ :type route_access_lists: RouteAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_access_lists_by_id_serialize(
+ id=id,
+ route_access_lists=route_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_access_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_access_lists: Annotated[Optional[RouteAccessLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteAccessLists]:
+ """Update a route access list
+
+ Update an existing route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_access_lists: OK
+ :type route_access_lists: RouteAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_access_lists_by_id_serialize(
+ id=id,
+ route_access_lists=route_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_access_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_access_lists: Annotated[Optional[RouteAccessLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a route access list
+
+ Update an existing route access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_access_lists: OK
+ :type route_access_lists: RouteAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_access_lists_by_id_serialize(
+ id=id,
+ route_access_lists=route_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_route_access_lists(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single route_access_lists object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_route_access_lists(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_route_access_lists(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_route_access_lists_by_id_serialize(
+ self,
+ id,
+ route_access_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_access_lists is not None:
+ _body_params = route_access_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/route-access-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/route_community_lists_api.py b/scm/network_services/api/route_community_lists_api.py
new file mode 100644
index 00000000..164f09be
--- /dev/null
+++ b/scm/network_services/api/route_community_lists_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.route_community_lists import RouteCommunityLists
+from scm.network_services.models.route_community_lists_list_response import RouteCommunityListsListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class RouteCommunityListsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_community_lists(
+ self,
+ route_community_lists: Annotated[Optional[RouteCommunityLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteCommunityLists:
+ """Create a route community list
+
+ Create a new route community list.
+
+ :param route_community_lists: Created
+ :type route_community_lists: RouteCommunityLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_community_lists_serialize(
+ route_community_lists=route_community_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_community_lists_with_http_info(
+ self,
+ route_community_lists: Annotated[Optional[RouteCommunityLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteCommunityLists]:
+ """Create a route community list
+
+ Create a new route community list.
+
+ :param route_community_lists: Created
+ :type route_community_lists: RouteCommunityLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_community_lists_serialize(
+ route_community_lists=route_community_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_community_lists_without_preload_content(
+ self,
+ route_community_lists: Annotated[Optional[RouteCommunityLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a route community list
+
+ Create a new route community list.
+
+ :param route_community_lists: Created
+ :type route_community_lists: RouteCommunityLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_community_lists_serialize(
+ route_community_lists=route_community_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_route_community_lists_serialize(
+ self,
+ route_community_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_community_lists is not None:
+ _body_params = route_community_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/route-community-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_community_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a route community list
+
+ Delete a route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_community_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_community_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a route community list
+
+ Delete a route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_community_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_community_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a route community list
+
+ Delete a route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_community_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_route_community_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/route-community-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_community_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteCommunityLists:
+ """Get a route community list
+
+ Get an existing route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_community_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_community_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteCommunityLists]:
+ """Get a route community list
+
+ Get an existing route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_community_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_community_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a route community list
+
+ Get an existing route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_community_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_route_community_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-community-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_community_lists(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteCommunityListsListResponse:
+ """List route community lists
+
+ Retrieve a list of route community lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_community_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_community_lists_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteCommunityListsListResponse]:
+ """List route community lists
+
+ Retrieve a list of route community lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_community_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_community_lists_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List route community lists
+
+ Retrieve a list of route community lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_community_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_route_community_lists_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-community-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_community_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_community_lists: Annotated[Optional[RouteCommunityLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RouteCommunityLists:
+ """Update a route community list
+
+ Update an existing route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_community_lists: OK
+ :type route_community_lists: RouteCommunityLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_community_lists_by_id_serialize(
+ id=id,
+ route_community_lists=route_community_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_community_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_community_lists: Annotated[Optional[RouteCommunityLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RouteCommunityLists]:
+ """Update a route community list
+
+ Update an existing route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_community_lists: OK
+ :type route_community_lists: RouteCommunityLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_community_lists_by_id_serialize(
+ id=id,
+ route_community_lists=route_community_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_community_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_community_lists: Annotated[Optional[RouteCommunityLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a route community list
+
+ Update an existing route community list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_community_lists: OK
+ :type route_community_lists: RouteCommunityLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_community_lists_by_id_serialize(
+ id=id,
+ route_community_lists=route_community_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RouteCommunityLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_route_community_lists(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single route_community_lists object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_route_community_lists(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_route_community_lists(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_route_community_lists_by_id_serialize(
+ self,
+ id,
+ route_community_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_community_lists is not None:
+ _body_params = route_community_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/route-community-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/route_path_access_lists_api.py b/scm/network_services/api/route_path_access_lists_api.py
new file mode 100644
index 00000000..1a70e6eb
--- /dev/null
+++ b/scm/network_services/api/route_path_access_lists_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.route_path_access_lists import RoutePathAccessLists
+from scm.network_services.models.route_path_access_lists_list_response import RoutePathAccessListsListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class RoutePathAccessListsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_path_access_lists(
+ self,
+ route_path_access_lists: Annotated[Optional[RoutePathAccessLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePathAccessLists:
+ """Create a route path access list
+
+ Create a new route path access list.
+
+ :param route_path_access_lists: Created
+ :type route_path_access_lists: RoutePathAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_path_access_lists_serialize(
+ route_path_access_lists=route_path_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_path_access_lists_with_http_info(
+ self,
+ route_path_access_lists: Annotated[Optional[RoutePathAccessLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePathAccessLists]:
+ """Create a route path access list
+
+ Create a new route path access list.
+
+ :param route_path_access_lists: Created
+ :type route_path_access_lists: RoutePathAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_path_access_lists_serialize(
+ route_path_access_lists=route_path_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_path_access_lists_without_preload_content(
+ self,
+ route_path_access_lists: Annotated[Optional[RoutePathAccessLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a route path access list
+
+ Create a new route path access list.
+
+ :param route_path_access_lists: Created
+ :type route_path_access_lists: RoutePathAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_path_access_lists_serialize(
+ route_path_access_lists=route_path_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_route_path_access_lists_serialize(
+ self,
+ route_path_access_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_path_access_lists is not None:
+ _body_params = route_path_access_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/route-path-access-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_path_access_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a route path access list
+
+ Delete a route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_path_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_path_access_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a route path access list
+
+ Delete a route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_path_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_path_access_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a route path access list
+
+ Delete a route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_path_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_route_path_access_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/route-path-access-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_path_access_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePathAccessLists:
+ """Get a route path access list
+
+ Get an existing route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_path_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_path_access_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePathAccessLists]:
+ """Get a route path access list
+
+ Get an existing route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_path_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_path_access_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a route path access list
+
+ Get an existing route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_path_access_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_route_path_access_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-path-access-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_path_access_lists(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePathAccessListsListResponse:
+ """List route path access lists
+
+ Retrieve a list of route path access lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_path_access_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_path_access_lists_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePathAccessListsListResponse]:
+ """List route path access lists
+
+ Retrieve a list of route path access lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_path_access_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_path_access_lists_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List route path access lists
+
+ Retrieve a list of route path access lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_path_access_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_route_path_access_lists_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-path-access-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_path_access_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_path_access_lists: Annotated[Optional[RoutePathAccessLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePathAccessLists:
+ """Update a route path access list
+
+ Update an existing route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_path_access_lists: OK
+ :type route_path_access_lists: RoutePathAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_path_access_lists_by_id_serialize(
+ id=id,
+ route_path_access_lists=route_path_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_path_access_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_path_access_lists: Annotated[Optional[RoutePathAccessLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePathAccessLists]:
+ """Update a route path access list
+
+ Update an existing route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_path_access_lists: OK
+ :type route_path_access_lists: RoutePathAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_path_access_lists_by_id_serialize(
+ id=id,
+ route_path_access_lists=route_path_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_path_access_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_path_access_lists: Annotated[Optional[RoutePathAccessLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a route path access list
+
+ Update an existing route path access list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_path_access_lists: OK
+ :type route_path_access_lists: RoutePathAccessLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_path_access_lists_by_id_serialize(
+ id=id,
+ route_path_access_lists=route_path_access_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePathAccessLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_route_path_access_lists(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single route_path_access_lists object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_route_path_access_lists(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_route_path_access_lists(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_route_path_access_lists_by_id_serialize(
+ self,
+ id,
+ route_path_access_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_path_access_lists is not None:
+ _body_params = route_path_access_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/route-path-access-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/route_prefix_lists_api.py b/scm/network_services/api/route_prefix_lists_api.py
new file mode 100644
index 00000000..3136609e
--- /dev/null
+++ b/scm/network_services/api/route_prefix_lists_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.route_prefix_lists import RoutePrefixLists
+from scm.network_services.models.route_prefix_lists_list_response import RoutePrefixListsListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class RoutePrefixListsApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_prefix_lists(
+ self,
+ route_prefix_lists: Annotated[Optional[RoutePrefixLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePrefixLists:
+ """Create a route prefix list
+
+ Create a new route prefix list.
+
+ :param route_prefix_lists: Created
+ :type route_prefix_lists: RoutePrefixLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_prefix_lists_serialize(
+ route_prefix_lists=route_prefix_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_prefix_lists_with_http_info(
+ self,
+ route_prefix_lists: Annotated[Optional[RoutePrefixLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePrefixLists]:
+ """Create a route prefix list
+
+ Create a new route prefix list.
+
+ :param route_prefix_lists: Created
+ :type route_prefix_lists: RoutePrefixLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_prefix_lists_serialize(
+ route_prefix_lists=route_prefix_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_route_prefix_lists_without_preload_content(
+ self,
+ route_prefix_lists: Annotated[Optional[RoutePrefixLists], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a route prefix list
+
+ Create a new route prefix list.
+
+ :param route_prefix_lists: Created
+ :type route_prefix_lists: RoutePrefixLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_route_prefix_lists_serialize(
+ route_prefix_lists=route_prefix_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_route_prefix_lists_serialize(
+ self,
+ route_prefix_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_prefix_lists is not None:
+ _body_params = route_prefix_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/route-prefix-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_prefix_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a route prefix list
+
+ Delete a route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_prefix_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_prefix_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a route prefix list
+
+ Delete a route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_prefix_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_route_prefix_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a route prefix list
+
+ Delete a route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_route_prefix_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_route_prefix_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/route-prefix-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_prefix_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePrefixLists:
+ """Get a route prefix list
+
+ Get an existing route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_prefix_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_prefix_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePrefixLists]:
+ """Get a route prefix list
+
+ Get an existing route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_prefix_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_route_prefix_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a route prefix list
+
+ Get an existing route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_route_prefix_lists_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_route_prefix_lists_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-prefix-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_prefix_lists(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePrefixListsListResponse:
+ """List route prefix lists
+
+ Retrieve a list of route prefix lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_prefix_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_prefix_lists_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePrefixListsListResponse]:
+ """List route prefix lists
+
+ Retrieve a list of route prefix lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_prefix_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_route_prefix_lists_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List route prefix lists
+
+ Retrieve a list of route prefix lists.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_route_prefix_lists_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixListsListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_route_prefix_lists_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/route-prefix-lists',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_prefix_lists_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_prefix_lists: Annotated[Optional[RoutePrefixLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RoutePrefixLists:
+ """Update a route prefix list
+
+ Update an existing route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_prefix_lists: OK
+ :type route_prefix_lists: RoutePrefixLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_prefix_lists_by_id_serialize(
+ id=id,
+ route_prefix_lists=route_prefix_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_prefix_lists_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_prefix_lists: Annotated[Optional[RoutePrefixLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[RoutePrefixLists]:
+ """Update a route prefix list
+
+ Update an existing route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_prefix_lists: OK
+ :type route_prefix_lists: RoutePrefixLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_prefix_lists_by_id_serialize(
+ id=id,
+ route_prefix_lists=route_prefix_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_route_prefix_lists_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ route_prefix_lists: Annotated[Optional[RoutePrefixLists], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a route prefix list
+
+ Update an existing route prefix list.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param route_prefix_lists: OK
+ :type route_prefix_lists: RoutePrefixLists
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_route_prefix_lists_by_id_serialize(
+ id=id,
+ route_prefix_lists=route_prefix_lists,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "RoutePrefixLists",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_route_prefix_lists(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single route_prefix_lists object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_route_prefix_lists(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_route_prefix_lists(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_route_prefix_lists_by_id_serialize(
+ self,
+ id,
+ route_prefix_lists,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if route_prefix_lists is not None:
+ _body_params = route_prefix_lists
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/route-prefix-lists/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/sdwan_error_correction_profiles_api.py b/scm/network_services/api/sdwan_error_correction_profiles_api.py
new file mode 100644
index 00000000..88420c47
--- /dev/null
+++ b/scm/network_services/api/sdwan_error_correction_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.sdwan_error_correction_profiles_list_response import SDWANErrorCorrectionProfilesListResponse
+from scm.network_services.models.sdwan_error_correction_profiles import SdwanErrorCorrectionProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SDWANErrorCorrectionProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_error_correction_profiles(
+ self,
+ sdwan_error_correction_profiles: Annotated[Optional[SdwanErrorCorrectionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanErrorCorrectionProfiles:
+ """Create an SD-WAN error correction profile
+
+ Create a new SD-WAN error correction profile.
+
+ :param sdwan_error_correction_profiles: Created
+ :type sdwan_error_correction_profiles: SdwanErrorCorrectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_error_correction_profiles_serialize(
+ sdwan_error_correction_profiles=sdwan_error_correction_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_error_correction_profiles_with_http_info(
+ self,
+ sdwan_error_correction_profiles: Annotated[Optional[SdwanErrorCorrectionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanErrorCorrectionProfiles]:
+ """Create an SD-WAN error correction profile
+
+ Create a new SD-WAN error correction profile.
+
+ :param sdwan_error_correction_profiles: Created
+ :type sdwan_error_correction_profiles: SdwanErrorCorrectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_error_correction_profiles_serialize(
+ sdwan_error_correction_profiles=sdwan_error_correction_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_error_correction_profiles_without_preload_content(
+ self,
+ sdwan_error_correction_profiles: Annotated[Optional[SdwanErrorCorrectionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an SD-WAN error correction profile
+
+ Create a new SD-WAN error correction profile.
+
+ :param sdwan_error_correction_profiles: Created
+ :type sdwan_error_correction_profiles: SdwanErrorCorrectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_error_correction_profiles_serialize(
+ sdwan_error_correction_profiles=sdwan_error_correction_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_sdwan_error_correction_profiles_serialize(
+ self,
+ sdwan_error_correction_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_error_correction_profiles is not None:
+ _body_params = sdwan_error_correction_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/sdwan-error-correction-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_error_correction_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an SD-WAN error correction profile
+
+ Delete an SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_error_correction_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an SD-WAN error correction profile
+
+ Delete an SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_error_correction_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an SD-WAN error correction profile
+
+ Delete an SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_sdwan_error_correction_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/sdwan-error-correction-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_error_correction_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanErrorCorrectionProfiles:
+ """Get an SD-WAN error correction profile
+
+ Get an existing SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_error_correction_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanErrorCorrectionProfiles]:
+ """Get an SD-WAN error correction profile
+
+ Get an existing SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_error_correction_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an SD-WAN error correction profile
+
+ Get an existing SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_sdwan_error_correction_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-error-correction-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_error_correction_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SDWANErrorCorrectionProfilesListResponse:
+ """List SD-WAN error correction profiles
+
+ Retrieve a list of SD-WAN error correction profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_error_correction_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANErrorCorrectionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_error_correction_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SDWANErrorCorrectionProfilesListResponse]:
+ """List SD-WAN error correction profiles
+
+ Retrieve a list of SD-WAN error correction profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_error_correction_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANErrorCorrectionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_error_correction_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List SD-WAN error correction profiles
+
+ Retrieve a list of SD-WAN error correction profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_error_correction_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANErrorCorrectionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_sdwan_error_correction_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-error-correction-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_error_correction_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_error_correction_profiles: Annotated[Optional[SdwanErrorCorrectionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanErrorCorrectionProfiles:
+ """Update an SD-WAN error correction profile
+
+ Update an existing SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_error_correction_profiles: OK
+ :type sdwan_error_correction_profiles: SdwanErrorCorrectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ sdwan_error_correction_profiles=sdwan_error_correction_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_error_correction_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_error_correction_profiles: Annotated[Optional[SdwanErrorCorrectionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanErrorCorrectionProfiles]:
+ """Update an SD-WAN error correction profile
+
+ Update an existing SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_error_correction_profiles: OK
+ :type sdwan_error_correction_profiles: SdwanErrorCorrectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ sdwan_error_correction_profiles=sdwan_error_correction_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_error_correction_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_error_correction_profiles: Annotated[Optional[SdwanErrorCorrectionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an SD-WAN error correction profile
+
+ Update an existing SD-WAN error correction profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_error_correction_profiles: OK
+ :type sdwan_error_correction_profiles: SdwanErrorCorrectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_error_correction_profiles_by_id_serialize(
+ id=id,
+ sdwan_error_correction_profiles=sdwan_error_correction_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanErrorCorrectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_sdwan_error_correction_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single sdwan_error_correction_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_sdwan_error_correction_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_sdwan_error_correction_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_sdwan_error_correction_profiles_by_id_serialize(
+ self,
+ id,
+ sdwan_error_correction_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_error_correction_profiles is not None:
+ _body_params = sdwan_error_correction_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/sdwan-error-correction-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/sdwan_path_quality_profiles_api.py b/scm/network_services/api/sdwan_path_quality_profiles_api.py
new file mode 100644
index 00000000..a2ee3528
--- /dev/null
+++ b/scm/network_services/api/sdwan_path_quality_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.sdwan_path_quality_profiles_list_response import SDWANPathQualityProfilesListResponse
+from scm.network_services.models.sdwan_path_quality_profiles import SdwanPathQualityProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SDWANPathQualityProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_path_quality_profiles(
+ self,
+ sdwan_path_quality_profiles: Annotated[Optional[SdwanPathQualityProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanPathQualityProfiles:
+ """Create an SD-WAN path quality profile
+
+ Create a new SD-WAN path quality profile.
+
+ :param sdwan_path_quality_profiles: Created
+ :type sdwan_path_quality_profiles: SdwanPathQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_path_quality_profiles_serialize(
+ sdwan_path_quality_profiles=sdwan_path_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_path_quality_profiles_with_http_info(
+ self,
+ sdwan_path_quality_profiles: Annotated[Optional[SdwanPathQualityProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanPathQualityProfiles]:
+ """Create an SD-WAN path quality profile
+
+ Create a new SD-WAN path quality profile.
+
+ :param sdwan_path_quality_profiles: Created
+ :type sdwan_path_quality_profiles: SdwanPathQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_path_quality_profiles_serialize(
+ sdwan_path_quality_profiles=sdwan_path_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_path_quality_profiles_without_preload_content(
+ self,
+ sdwan_path_quality_profiles: Annotated[Optional[SdwanPathQualityProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an SD-WAN path quality profile
+
+ Create a new SD-WAN path quality profile.
+
+ :param sdwan_path_quality_profiles: Created
+ :type sdwan_path_quality_profiles: SdwanPathQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_path_quality_profiles_serialize(
+ sdwan_path_quality_profiles=sdwan_path_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_sdwan_path_quality_profiles_serialize(
+ self,
+ sdwan_path_quality_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_path_quality_profiles is not None:
+ _body_params = sdwan_path_quality_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/sdwan-path-quality-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_path_quality_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an SD-WAN path quality profile
+
+ Delete an SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_path_quality_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an SD-WAN path quality profile
+
+ Delete an SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_path_quality_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an SD-WAN path quality profile
+
+ Delete an SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_sdwan_path_quality_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/sdwan-path-quality-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_path_quality_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanPathQualityProfiles:
+ """Get an SD-WAN path quality profile
+
+ Get an existing SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_path_quality_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanPathQualityProfiles]:
+ """Get an SD-WAN path quality profile
+
+ Get an existing SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_path_quality_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an SD-WAN path quality profile
+
+ Get an existing SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_sdwan_path_quality_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-path-quality-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_path_quality_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SDWANPathQualityProfilesListResponse:
+ """List SD-WAN path quality profiles
+
+ Retrieve a list of SD-WAN path quality profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_path_quality_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANPathQualityProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_path_quality_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SDWANPathQualityProfilesListResponse]:
+ """List SD-WAN path quality profiles
+
+ Retrieve a list of SD-WAN path quality profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_path_quality_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANPathQualityProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_path_quality_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List SD-WAN path quality profiles
+
+ Retrieve a list of SD-WAN path quality profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_path_quality_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANPathQualityProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_sdwan_path_quality_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-path-quality-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_path_quality_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_path_quality_profiles: Annotated[Optional[SdwanPathQualityProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanPathQualityProfiles:
+ """Update an SD-WAN path quality profile
+
+ Update an existing SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_path_quality_profiles: OK
+ :type sdwan_path_quality_profiles: SdwanPathQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ sdwan_path_quality_profiles=sdwan_path_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_path_quality_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_path_quality_profiles: Annotated[Optional[SdwanPathQualityProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanPathQualityProfiles]:
+ """Update an SD-WAN path quality profile
+
+ Update an existing SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_path_quality_profiles: OK
+ :type sdwan_path_quality_profiles: SdwanPathQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ sdwan_path_quality_profiles=sdwan_path_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_path_quality_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_path_quality_profiles: Annotated[Optional[SdwanPathQualityProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an SD-WAN path quality profile
+
+ Update an existing SD-WAN path quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_path_quality_profiles: OK
+ :type sdwan_path_quality_profiles: SdwanPathQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_path_quality_profiles_by_id_serialize(
+ id=id,
+ sdwan_path_quality_profiles=sdwan_path_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanPathQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_sdwan_path_quality_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single sdwan_path_quality_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_sdwan_path_quality_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_sdwan_path_quality_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_sdwan_path_quality_profiles_by_id_serialize(
+ self,
+ id,
+ sdwan_path_quality_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_path_quality_profiles is not None:
+ _body_params = sdwan_path_quality_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/sdwan-path-quality-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/sdwan_rules_api.py b/scm/network_services/api/sdwan_rules_api.py
new file mode 100644
index 00000000..6d4ddc2c
--- /dev/null
+++ b/scm/network_services/api/sdwan_rules_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.sdwan_rules_list_response import SDWANRulesListResponse
+from scm.network_services.models.sdwan_rules import SdwanRules
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SDWANRulesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_rules(
+ self,
+ sdwan_rules: Annotated[Optional[SdwanRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanRules:
+ """Create an SD-WAN rule
+
+ Create a new SD-WAN rule.
+
+ :param sdwan_rules: Created
+ :type sdwan_rules: SdwanRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_rules_serialize(
+ sdwan_rules=sdwan_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_rules_with_http_info(
+ self,
+ sdwan_rules: Annotated[Optional[SdwanRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanRules]:
+ """Create an SD-WAN rule
+
+ Create a new SD-WAN rule.
+
+ :param sdwan_rules: Created
+ :type sdwan_rules: SdwanRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_rules_serialize(
+ sdwan_rules=sdwan_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_rules_without_preload_content(
+ self,
+ sdwan_rules: Annotated[Optional[SdwanRules], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an SD-WAN rule
+
+ Create a new SD-WAN rule.
+
+ :param sdwan_rules: Created
+ :type sdwan_rules: SdwanRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_rules_serialize(
+ sdwan_rules=sdwan_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_sdwan_rules_serialize(
+ self,
+ sdwan_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_rules is not None:
+ _body_params = sdwan_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/sdwan-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an SD-WAN rule
+
+ Delete an SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an SD-WAN rule
+
+ Delete an SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an SD-WAN rule
+
+ Delete an SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_sdwan_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/sdwan-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanRules:
+ """Get an SD-WAN rule
+
+ Get an existing SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanRules]:
+ """Get an SD-WAN rule
+
+ Get an existing SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an SD-WAN rule
+
+ Get an existing SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_rules_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_sdwan_rules_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_rules(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SDWANRulesListResponse:
+ """List SD-WAN rules
+
+ Retrieve a list of SD-WAN rules.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_rules_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_rules_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SDWANRulesListResponse]:
+ """List SD-WAN rules
+
+ Retrieve a list of SD-WAN rules.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_rules_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_rules_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List SD-WAN rules
+
+ Retrieve a list of SD-WAN rules.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_rules_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANRulesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_sdwan_rules_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-rules',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_rules_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_rules: Annotated[Optional[SdwanRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanRules:
+ """Update an SD-WAN rule
+
+ Update an existing SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_rules: OK
+ :type sdwan_rules: SdwanRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_rules_by_id_serialize(
+ id=id,
+ sdwan_rules=sdwan_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_rules_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_rules: Annotated[Optional[SdwanRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanRules]:
+ """Update an SD-WAN rule
+
+ Update an existing SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_rules: OK
+ :type sdwan_rules: SdwanRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_rules_by_id_serialize(
+ id=id,
+ sdwan_rules=sdwan_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_rules_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_rules: Annotated[Optional[SdwanRules], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an SD-WAN rule
+
+ Update an existing SD-WAN rule.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_rules: OK
+ :type sdwan_rules: SdwanRules
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_rules_by_id_serialize(
+ id=id,
+ sdwan_rules=sdwan_rules,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanRules",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_sdwan_rules(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single sdwan_rules object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_sdwan_rules(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_sdwan_rules(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_sdwan_rules_by_id_serialize(
+ self,
+ id,
+ sdwan_rules,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_rules is not None:
+ _body_params = sdwan_rules
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/sdwan-rules/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/sdwan_saas_quality_profiles_api.py b/scm/network_services/api/sdwan_saas_quality_profiles_api.py
new file mode 100644
index 00000000..66897419
--- /dev/null
+++ b/scm/network_services/api/sdwan_saas_quality_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.sdwan_saas_quality_profiles_list_response import SDWANSaaSQualityProfilesListResponse
+from scm.network_services.models.sdwan_saas_quality_profiles import SdwanSaasQualityProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SDWANSaaSQualityProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_saa_s_quality_profiles(
+ self,
+ sdwan_saas_quality_profiles: Annotated[Optional[SdwanSaasQualityProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanSaasQualityProfiles:
+ """Create an SD-WAN SaaS quality profile
+
+ Create a new SD-WAN SaaS quality profile.
+
+ :param sdwan_saas_quality_profiles: Created
+ :type sdwan_saas_quality_profiles: SdwanSaasQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_saa_s_quality_profiles_serialize(
+ sdwan_saas_quality_profiles=sdwan_saas_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_saa_s_quality_profiles_with_http_info(
+ self,
+ sdwan_saas_quality_profiles: Annotated[Optional[SdwanSaasQualityProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanSaasQualityProfiles]:
+ """Create an SD-WAN SaaS quality profile
+
+ Create a new SD-WAN SaaS quality profile.
+
+ :param sdwan_saas_quality_profiles: Created
+ :type sdwan_saas_quality_profiles: SdwanSaasQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_saa_s_quality_profiles_serialize(
+ sdwan_saas_quality_profiles=sdwan_saas_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_saa_s_quality_profiles_without_preload_content(
+ self,
+ sdwan_saas_quality_profiles: Annotated[Optional[SdwanSaasQualityProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an SD-WAN SaaS quality profile
+
+ Create a new SD-WAN SaaS quality profile.
+
+ :param sdwan_saas_quality_profiles: Created
+ :type sdwan_saas_quality_profiles: SdwanSaasQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_saa_s_quality_profiles_serialize(
+ sdwan_saas_quality_profiles=sdwan_saas_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_sdwan_saa_s_quality_profiles_serialize(
+ self,
+ sdwan_saas_quality_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_saas_quality_profiles is not None:
+ _body_params = sdwan_saas_quality_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/sdwan-saas-quality-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_saa_s_quality_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an SD-WAN SaaS quality profile
+
+ Delete an SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_saa_s_quality_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an SD-WAN SaaS quality profile
+
+ Delete an SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_saa_s_quality_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an SD-WAN SaaS quality profile
+
+ Delete an SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_sdwan_saa_s_quality_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/sdwan-saas-quality-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_saa_s_quality_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanSaasQualityProfiles:
+ """Get an SD-WAN SaaS quality profile
+
+ Get an existing SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_saa_s_quality_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanSaasQualityProfiles]:
+ """Get an SD-WAN SaaS quality profile
+
+ Get an existing SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_saa_s_quality_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an SD-WAN SaaS quality profile
+
+ Get an existing SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_sdwan_saa_s_quality_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-saas-quality-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_saa_s_quality_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SDWANSaaSQualityProfilesListResponse:
+ """List SD-WAN SaaS quality profiles
+
+ Retrieve a list of SD-WAN SaaS quality profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_saa_s_quality_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANSaaSQualityProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_saa_s_quality_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SDWANSaaSQualityProfilesListResponse]:
+ """List SD-WAN SaaS quality profiles
+
+ Retrieve a list of SD-WAN SaaS quality profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_saa_s_quality_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANSaaSQualityProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_saa_s_quality_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List SD-WAN SaaS quality profiles
+
+ Retrieve a list of SD-WAN SaaS quality profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_saa_s_quality_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANSaaSQualityProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_sdwan_saa_s_quality_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-saas-quality-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_saa_s_quality_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_saas_quality_profiles: Annotated[Optional[SdwanSaasQualityProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanSaasQualityProfiles:
+ """Update an SD-WAN SaaS quality profile
+
+ Update an existing SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_saas_quality_profiles: OK
+ :type sdwan_saas_quality_profiles: SdwanSaasQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ sdwan_saas_quality_profiles=sdwan_saas_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_saa_s_quality_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_saas_quality_profiles: Annotated[Optional[SdwanSaasQualityProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanSaasQualityProfiles]:
+ """Update an SD-WAN SaaS quality profile
+
+ Update an existing SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_saas_quality_profiles: OK
+ :type sdwan_saas_quality_profiles: SdwanSaasQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ sdwan_saas_quality_profiles=sdwan_saas_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_saa_s_quality_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_saas_quality_profiles: Annotated[Optional[SdwanSaasQualityProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an SD-WAN SaaS quality profile
+
+ Update an existing SD-WAN SaaS quality profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_saas_quality_profiles: OK
+ :type sdwan_saas_quality_profiles: SdwanSaasQualityProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_saa_s_quality_profiles_by_id_serialize(
+ id=id,
+ sdwan_saas_quality_profiles=sdwan_saas_quality_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanSaasQualityProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_sdwan_saas_quality_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single sdwan_saas_quality_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_sdwan_saas_quality_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_sdwan_saa_s_quality_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_sdwan_saa_s_quality_profiles_by_id_serialize(
+ self,
+ id,
+ sdwan_saas_quality_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_saas_quality_profiles is not None:
+ _body_params = sdwan_saas_quality_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/sdwan-saas-quality-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/sdwan_traffic_distribution_profiles_api.py b/scm/network_services/api/sdwan_traffic_distribution_profiles_api.py
new file mode 100644
index 00000000..0a387abe
--- /dev/null
+++ b/scm/network_services/api/sdwan_traffic_distribution_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.sdwan_traffic_distribution_profiles_list_response import SDWANTrafficDistributionProfilesListResponse
+from scm.network_services.models.sdwan_traffic_distribution_profiles import SdwanTrafficDistributionProfiles
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SDWANTrafficDistributionProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_traffic_distribution_profiles(
+ self,
+ sdwan_traffic_distribution_profiles: Annotated[Optional[SdwanTrafficDistributionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanTrafficDistributionProfiles:
+ """Create an SD-WAN traffic distribution profile
+
+ Create a new SD-WAN traffic distribution profile.
+
+ :param sdwan_traffic_distribution_profiles: Created
+ :type sdwan_traffic_distribution_profiles: SdwanTrafficDistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_traffic_distribution_profiles_serialize(
+ sdwan_traffic_distribution_profiles=sdwan_traffic_distribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_traffic_distribution_profiles_with_http_info(
+ self,
+ sdwan_traffic_distribution_profiles: Annotated[Optional[SdwanTrafficDistributionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanTrafficDistributionProfiles]:
+ """Create an SD-WAN traffic distribution profile
+
+ Create a new SD-WAN traffic distribution profile.
+
+ :param sdwan_traffic_distribution_profiles: Created
+ :type sdwan_traffic_distribution_profiles: SdwanTrafficDistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_traffic_distribution_profiles_serialize(
+ sdwan_traffic_distribution_profiles=sdwan_traffic_distribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_sdwan_traffic_distribution_profiles_without_preload_content(
+ self,
+ sdwan_traffic_distribution_profiles: Annotated[Optional[SdwanTrafficDistributionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create an SD-WAN traffic distribution profile
+
+ Create a new SD-WAN traffic distribution profile.
+
+ :param sdwan_traffic_distribution_profiles: Created
+ :type sdwan_traffic_distribution_profiles: SdwanTrafficDistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_sdwan_traffic_distribution_profiles_serialize(
+ sdwan_traffic_distribution_profiles=sdwan_traffic_distribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_sdwan_traffic_distribution_profiles_serialize(
+ self,
+ sdwan_traffic_distribution_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_traffic_distribution_profiles is not None:
+ _body_params = sdwan_traffic_distribution_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/sdwan-traffic-distribution-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_traffic_distribution_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete an SD-WAN traffic distribution profile
+
+ Delete an SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_traffic_distribution_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete an SD-WAN traffic distribution profile
+
+ Delete an SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_sdwan_traffic_distribution_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete an SD-WAN traffic distribution profile
+
+ Delete an SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_sdwan_traffic_distribution_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/sdwan-traffic-distribution-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_traffic_distribution_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanTrafficDistributionProfiles:
+ """Get an SD-WAN traffic distribution profile
+
+ Get an existing SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_traffic_distribution_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanTrafficDistributionProfiles]:
+ """Get an SD-WAN traffic distribution profile
+
+ Get an existing SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_sdwan_traffic_distribution_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get an SD-WAN traffic distribution profile
+
+ Get an existing SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_sdwan_traffic_distribution_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-traffic-distribution-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_traffic_distribution_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SDWANTrafficDistributionProfilesListResponse:
+ """List SD-WAN traffic distribution profiles
+
+ Retrieve a list of SD-WAN traffic distribution profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_traffic_distribution_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANTrafficDistributionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_traffic_distribution_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SDWANTrafficDistributionProfilesListResponse]:
+ """List SD-WAN traffic distribution profiles
+
+ Retrieve a list of SD-WAN traffic distribution profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_traffic_distribution_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANTrafficDistributionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_sdwan_traffic_distribution_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List SD-WAN traffic distribution profiles
+
+ Retrieve a list of SD-WAN traffic distribution profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_sdwan_traffic_distribution_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SDWANTrafficDistributionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_sdwan_traffic_distribution_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/sdwan-traffic-distribution-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_traffic_distribution_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_traffic_distribution_profiles: Annotated[Optional[SdwanTrafficDistributionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SdwanTrafficDistributionProfiles:
+ """Update an SD-WAN traffic distribution profile
+
+ Update an existing SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_traffic_distribution_profiles: OK
+ :type sdwan_traffic_distribution_profiles: SdwanTrafficDistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ sdwan_traffic_distribution_profiles=sdwan_traffic_distribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_traffic_distribution_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_traffic_distribution_profiles: Annotated[Optional[SdwanTrafficDistributionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SdwanTrafficDistributionProfiles]:
+ """Update an SD-WAN traffic distribution profile
+
+ Update an existing SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_traffic_distribution_profiles: OK
+ :type sdwan_traffic_distribution_profiles: SdwanTrafficDistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ sdwan_traffic_distribution_profiles=sdwan_traffic_distribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_sdwan_traffic_distribution_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ sdwan_traffic_distribution_profiles: Annotated[Optional[SdwanTrafficDistributionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update an SD-WAN traffic distribution profile
+
+ Update an existing SD-WAN traffic distribution profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param sdwan_traffic_distribution_profiles: OK
+ :type sdwan_traffic_distribution_profiles: SdwanTrafficDistributionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_sdwan_traffic_distribution_profiles_by_id_serialize(
+ id=id,
+ sdwan_traffic_distribution_profiles=sdwan_traffic_distribution_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SdwanTrafficDistributionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_sdwan_traffic_distribution_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single sdwan_traffic_distribution_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_sdwan_traffic_distribution_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_sdwan_traffic_distribution_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_sdwan_traffic_distribution_profiles_by_id_serialize(
+ self,
+ id,
+ sdwan_traffic_distribution_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if sdwan_traffic_distribution_profiles is not None:
+ _body_params = sdwan_traffic_distribution_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/sdwan-traffic-distribution-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/security_zones_api.py b/scm/network_services/api/security_zones_api.py
new file mode 100644
index 00000000..7a523d49
--- /dev/null
+++ b/scm/network_services/api/security_zones_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.zones import Zones
+from scm.network_services.models.zones_list_response import ZonesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SecurityZonesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_zones(
+ self,
+ zones: Annotated[Optional[Zones], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Zones:
+ """Create a security zone
+
+ Create a new security zone.
+
+ :param zones: Created
+ :type zones: Zones
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_zones_serialize(
+ zones=zones,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_zones_with_http_info(
+ self,
+ zones: Annotated[Optional[Zones], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Zones]:
+ """Create a security zone
+
+ Create a new security zone.
+
+ :param zones: Created
+ :type zones: Zones
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_zones_serialize(
+ zones=zones,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_zones_without_preload_content(
+ self,
+ zones: Annotated[Optional[Zones], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a security zone
+
+ Create a new security zone.
+
+ :param zones: Created
+ :type zones: Zones
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_zones_serialize(
+ zones=zones,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_zones_serialize(
+ self,
+ zones,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if zones is not None:
+ _body_params = zones
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/zones',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_zones_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a security zone
+
+ Delete a security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_zones_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_zones_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a security zone
+
+ Delete a security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_zones_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_zones_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a security zone
+
+ Delete a security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_zones_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_zones_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/zones/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_zones_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Zones:
+ """Get a security zone
+
+ Get an existing security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_zones_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_zones_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Zones]:
+ """Get a security zone
+
+ Get an existing security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_zones_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_zones_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a security zone
+
+ Get an existing security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_zones_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_zones_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/zones/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_zones(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ZonesListResponse:
+ """List security zones
+
+ Retrieve a list of security zones.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_zones_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZonesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_zones_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ZonesListResponse]:
+ """List security zones
+
+ Retrieve a list of security zones.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_zones_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZonesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_zones_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List security zones
+
+ Retrieve a list of security zones.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_zones_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZonesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_zones_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/zones',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_zones_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ zones: Annotated[Optional[Zones], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> Zones:
+ """Update a security zone
+
+ Update an existing security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param zones: OK
+ :type zones: Zones
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_zones_by_id_serialize(
+ id=id,
+ zones=zones,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_zones_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ zones: Annotated[Optional[Zones], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[Zones]:
+ """Update a security zone
+
+ Update an existing security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param zones: OK
+ :type zones: Zones
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_zones_by_id_serialize(
+ id=id,
+ zones=zones,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_zones_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ zones: Annotated[Optional[Zones], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a security zone
+
+ Update an existing security zone.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param zones: OK
+ :type zones: Zones
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_zones_by_id_serialize(
+ id=id,
+ zones=zones,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "Zones",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_security_zones(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single security_zones object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_security_zones(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_zones(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_zones_by_id_serialize(
+ self,
+ id,
+ zones,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if zones is not None:
+ _body_params = zones
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/zones/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/system_match_list_api.py b/scm/network_services/api/system_match_list_api.py
new file mode 100644
index 00000000..64cb9159
--- /dev/null
+++ b/scm/network_services/api/system_match_list_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.system_match_list import SystemMatchList
+from scm.network_services.models.system_match_list_list_response import SystemMatchListListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class SystemMatchListApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_system_match_list(
+ self,
+ system_match_list: Annotated[Optional[SystemMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SystemMatchList:
+ """Create a system match list entry
+
+ Create a new system match list entry.
+
+ :param system_match_list: Created
+ :type system_match_list: SystemMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_system_match_list_serialize(
+ system_match_list=system_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_system_match_list_with_http_info(
+ self,
+ system_match_list: Annotated[Optional[SystemMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SystemMatchList]:
+ """Create a system match list entry
+
+ Create a new system match list entry.
+
+ :param system_match_list: Created
+ :type system_match_list: SystemMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_system_match_list_serialize(
+ system_match_list=system_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_system_match_list_without_preload_content(
+ self,
+ system_match_list: Annotated[Optional[SystemMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a system match list entry
+
+ Create a new system match list entry.
+
+ :param system_match_list: Created
+ :type system_match_list: SystemMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_system_match_list_serialize(
+ system_match_list=system_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_system_match_list_serialize(
+ self,
+ system_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if system_match_list is not None:
+ _body_params = system_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/system-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_system_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a system match list entry
+
+ Delete a system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_system_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_system_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a system match list entry
+
+ Delete a system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_system_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_system_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a system match list entry
+
+ Delete a system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_system_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_system_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/system-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_system_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SystemMatchList:
+ """Get a system match list entry
+
+ Get an existing system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_system_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_system_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SystemMatchList]:
+ """Get a system match list entry
+
+ Get an existing system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_system_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_system_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a system match list entry
+
+ Get an existing system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_system_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_system_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/system-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_system_match_list(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SystemMatchListListResponse:
+ """List system match list entries
+
+ Retrieve a list of system match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_system_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_system_match_list_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SystemMatchListListResponse]:
+ """List system match list entries
+
+ Retrieve a list of system match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_system_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_system_match_list_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List system match list entries
+
+ Retrieve a list of system match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_system_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_system_match_list_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/system-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_system_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ system_match_list: Annotated[Optional[SystemMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> SystemMatchList:
+ """Update a system match list entry
+
+ Update an existing system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param system_match_list: OK
+ :type system_match_list: SystemMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_system_match_list_by_id_serialize(
+ id=id,
+ system_match_list=system_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_system_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ system_match_list: Annotated[Optional[SystemMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[SystemMatchList]:
+ """Update a system match list entry
+
+ Update an existing system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param system_match_list: OK
+ :type system_match_list: SystemMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_system_match_list_by_id_serialize(
+ id=id,
+ system_match_list=system_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_system_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ system_match_list: Annotated[Optional[SystemMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a system match list entry
+
+ Update an existing system match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param system_match_list: OK
+ :type system_match_list: SystemMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_system_match_list_by_id_serialize(
+ id=id,
+ system_match_list=system_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "SystemMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_system_match_list(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single system_match_list object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_system_match_list(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_system_match_list(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_system_match_list_by_id_serialize(
+ self,
+ id,
+ system_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if system_match_list is not None:
+ _body_params = system_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/system-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/tunnel_interfaces_api.py b/scm/network_services/api/tunnel_interfaces_api.py
new file mode 100644
index 00000000..aad4dc6b
--- /dev/null
+++ b/scm/network_services/api/tunnel_interfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.tunnel_interfaces import TunnelInterfaces
+from scm.network_services.models.tunnel_interfaces_list_response import TunnelInterfacesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class TunnelInterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_tunnel_interfaces(
+ self,
+ tunnel_interfaces: Annotated[Optional[TunnelInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TunnelInterfaces:
+ """Create a tunnel interface
+
+ Create a new tunnel interface.
+
+ :param tunnel_interfaces: Created
+ :type tunnel_interfaces: TunnelInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tunnel_interfaces_serialize(
+ tunnel_interfaces=tunnel_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_tunnel_interfaces_with_http_info(
+ self,
+ tunnel_interfaces: Annotated[Optional[TunnelInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TunnelInterfaces]:
+ """Create a tunnel interface
+
+ Create a new tunnel interface.
+
+ :param tunnel_interfaces: Created
+ :type tunnel_interfaces: TunnelInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tunnel_interfaces_serialize(
+ tunnel_interfaces=tunnel_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_tunnel_interfaces_without_preload_content(
+ self,
+ tunnel_interfaces: Annotated[Optional[TunnelInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a tunnel interface
+
+ Create a new tunnel interface.
+
+ :param tunnel_interfaces: Created
+ :type tunnel_interfaces: TunnelInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_tunnel_interfaces_serialize(
+ tunnel_interfaces=tunnel_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_tunnel_interfaces_serialize(
+ self,
+ tunnel_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tunnel_interfaces is not None:
+ _body_params = tunnel_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/tunnel-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tunnel_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a tunnel interface
+
+ Delete a tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tunnel_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tunnel_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a tunnel interface
+
+ Delete a tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tunnel_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_tunnel_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a tunnel interface
+
+ Delete a tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_tunnel_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_tunnel_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/tunnel-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_tunnel_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TunnelInterfaces:
+ """Get a tunnel interface
+
+ Get an existing tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tunnel_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_tunnel_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TunnelInterfaces]:
+ """Get a tunnel interface
+
+ Get an existing tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tunnel_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_tunnel_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a tunnel interface
+
+ Get an existing tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_tunnel_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_tunnel_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tunnel-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_tunnel_interfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TunnelInterfacesListResponse:
+ """List tunnel interfaces
+
+ Retrieve a list of tunnel interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tunnel_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_tunnel_interfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TunnelInterfacesListResponse]:
+ """List tunnel interfaces
+
+ Retrieve a list of tunnel interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tunnel_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_tunnel_interfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List tunnel interfaces
+
+ Retrieve a list of tunnel interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_tunnel_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_tunnel_interfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/tunnel-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_tunnel_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tunnel_interfaces: Annotated[Optional[TunnelInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> TunnelInterfaces:
+ """Update a tunnel interface
+
+ Update an existing tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tunnel_interfaces: OK
+ :type tunnel_interfaces: TunnelInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tunnel_interfaces_by_id_serialize(
+ id=id,
+ tunnel_interfaces=tunnel_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_tunnel_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tunnel_interfaces: Annotated[Optional[TunnelInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[TunnelInterfaces]:
+ """Update a tunnel interface
+
+ Update an existing tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tunnel_interfaces: OK
+ :type tunnel_interfaces: TunnelInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tunnel_interfaces_by_id_serialize(
+ id=id,
+ tunnel_interfaces=tunnel_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_tunnel_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ tunnel_interfaces: Annotated[Optional[TunnelInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a tunnel interface
+
+ Update an existing tunnel interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param tunnel_interfaces: OK
+ :type tunnel_interfaces: TunnelInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_tunnel_interfaces_by_id_serialize(
+ id=id,
+ tunnel_interfaces=tunnel_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "TunnelInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_tunnel_interfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single tunnel_interfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_tunnel_interfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_tunnel_interfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_tunnel_interfaces_by_id_serialize(
+ self,
+ id,
+ tunnel_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if tunnel_interfaces is not None:
+ _body_params = tunnel_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/tunnel-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/userid_match_list_api.py b/scm/network_services/api/userid_match_list_api.py
new file mode 100644
index 00000000..547b0340
--- /dev/null
+++ b/scm/network_services/api/userid_match_list_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.userid_match_list import UseridMatchList
+from scm.network_services.models.userid_match_list_list_response import UseridMatchListListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class UseridMatchListApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_userid_match_list(
+ self,
+ userid_match_list: Annotated[Optional[UseridMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> UseridMatchList:
+ """Create a userid match list entry
+
+ Create a new userid match list entry.
+
+ :param userid_match_list: Created
+ :type userid_match_list: UseridMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_userid_match_list_serialize(
+ userid_match_list=userid_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_userid_match_list_with_http_info(
+ self,
+ userid_match_list: Annotated[Optional[UseridMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[UseridMatchList]:
+ """Create a userid match list entry
+
+ Create a new userid match list entry.
+
+ :param userid_match_list: Created
+ :type userid_match_list: UseridMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_userid_match_list_serialize(
+ userid_match_list=userid_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_userid_match_list_without_preload_content(
+ self,
+ userid_match_list: Annotated[Optional[UseridMatchList], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a userid match list entry
+
+ Create a new userid match list entry.
+
+ :param userid_match_list: Created
+ :type userid_match_list: UseridMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_userid_match_list_serialize(
+ userid_match_list=userid_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_userid_match_list_serialize(
+ self,
+ userid_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if userid_match_list is not None:
+ _body_params = userid_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/userid-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_userid_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a userid match list entry
+
+ Delete a userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_userid_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_userid_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a userid match list entry
+
+ Delete a userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_userid_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_userid_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a userid match list entry
+
+ Delete a userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_userid_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_userid_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/userid-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_userid_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> UseridMatchList:
+ """Get a userid match list entry
+
+ Get an existing userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_userid_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_userid_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[UseridMatchList]:
+ """Get a userid match list entry
+
+ Get an existing userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_userid_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_userid_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a userid match list entry
+
+ Get an existing userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_userid_match_list_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_userid_match_list_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/userid-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_userid_match_list(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> UseridMatchListListResponse:
+ """List userid match list entries
+
+ Retrieve a list of userid match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_userid_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_userid_match_list_with_http_info(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[UseridMatchListListResponse]:
+ """List userid match list entries
+
+ Retrieve a list of userid match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_userid_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_userid_match_list_without_preload_content(
+ self,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List userid match list entries
+
+ Retrieve a list of userid match list entries.
+
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_userid_match_list_serialize(
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ offset=offset,
+ limit=limit,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchListListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_userid_match_list_serialize(
+ self,
+ name,
+ folder,
+ snippet,
+ device,
+ offset,
+ limit,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/userid-match-list',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_userid_match_list_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ userid_match_list: Annotated[Optional[UseridMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> UseridMatchList:
+ """Update a userid match list entry
+
+ Update an existing userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param userid_match_list: OK
+ :type userid_match_list: UseridMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_userid_match_list_by_id_serialize(
+ id=id,
+ userid_match_list=userid_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_userid_match_list_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ userid_match_list: Annotated[Optional[UseridMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[UseridMatchList]:
+ """Update a userid match list entry
+
+ Update an existing userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param userid_match_list: OK
+ :type userid_match_list: UseridMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_userid_match_list_by_id_serialize(
+ id=id,
+ userid_match_list=userid_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_userid_match_list_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ userid_match_list: Annotated[Optional[UseridMatchList], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a userid match list entry
+
+ Update an existing userid match list entry.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param userid_match_list: OK
+ :type userid_match_list: UseridMatchList
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_userid_match_list_by_id_serialize(
+ id=id,
+ userid_match_list=userid_match_list,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "UseridMatchList",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_userid_match_list(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single userid_match_list object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_userid_match_list(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_userid_match_list(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_userid_match_list_by_id_serialize(
+ self,
+ id,
+ userid_match_list,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if userid_match_list is not None:
+ _body_params = userid_match_list
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/userid-match-list/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/vlan_interfaces_api.py b/scm/network_services/api/vlan_interfaces_api.py
new file mode 100644
index 00000000..4d034c58
--- /dev/null
+++ b/scm/network_services/api/vlan_interfaces_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.vlan_interfaces_list_response import VLANInterfacesListResponse
+from scm.network_services.models.vlan_interfaces import VlanInterfaces
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class VLANInterfacesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_vlan_interfaces(
+ self,
+ vlan_interfaces: Annotated[Optional[VlanInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VlanInterfaces:
+ """Create a VLAN interface
+
+ Create a new VLAN interface.
+
+ :param vlan_interfaces: Created
+ :type vlan_interfaces: VlanInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_vlan_interfaces_serialize(
+ vlan_interfaces=vlan_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_vlan_interfaces_with_http_info(
+ self,
+ vlan_interfaces: Annotated[Optional[VlanInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VlanInterfaces]:
+ """Create a VLAN interface
+
+ Create a new VLAN interface.
+
+ :param vlan_interfaces: Created
+ :type vlan_interfaces: VlanInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_vlan_interfaces_serialize(
+ vlan_interfaces=vlan_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_vlan_interfaces_without_preload_content(
+ self,
+ vlan_interfaces: Annotated[Optional[VlanInterfaces], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a VLAN interface
+
+ Create a new VLAN interface.
+
+ :param vlan_interfaces: Created
+ :type vlan_interfaces: VlanInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_vlan_interfaces_serialize(
+ vlan_interfaces=vlan_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_vlan_interfaces_serialize(
+ self,
+ vlan_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if vlan_interfaces is not None:
+ _body_params = vlan_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/vlan-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_vlan_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a VLAN interface
+
+ Delete a VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_vlan_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_vlan_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a VLAN interface
+
+ Delete a VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_vlan_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_vlan_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a VLAN interface
+
+ Delete a VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_vlan_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_vlan_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/vlan-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_vlan_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VlanInterfaces:
+ """Get a VLAN interface
+
+ Get an existing VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_vlan_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_vlan_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VlanInterfaces]:
+ """Get a VLAN interface
+
+ Get an existing VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_vlan_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_vlan_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a VLAN interface
+
+ Get an existing VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_vlan_interfaces_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_vlan_interfaces_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/vlan-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_vlan_interfaces(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VLANInterfacesListResponse:
+ """List VLAN interfaces
+
+ Retrieve a list of VLAN interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_vlan_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VLANInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_vlan_interfaces_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VLANInterfacesListResponse]:
+ """List VLAN interfaces
+
+ Retrieve a list of VLAN interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_vlan_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VLANInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_vlan_interfaces_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List VLAN interfaces
+
+ Retrieve a list of VLAN interfaces.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_vlan_interfaces_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VLANInterfacesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_vlan_interfaces_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/vlan-interfaces',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_vlanl_interfaces_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ vlan_interfaces: Annotated[Optional[VlanInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> VlanInterfaces:
+ """Update a VLAN interface
+
+ Update an existing VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param vlan_interfaces: OK
+ :type vlan_interfaces: VlanInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_vlanl_interfaces_by_id_serialize(
+ id=id,
+ vlan_interfaces=vlan_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_vlanl_interfaces_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ vlan_interfaces: Annotated[Optional[VlanInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[VlanInterfaces]:
+ """Update a VLAN interface
+
+ Update an existing VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param vlan_interfaces: OK
+ :type vlan_interfaces: VlanInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_vlanl_interfaces_by_id_serialize(
+ id=id,
+ vlan_interfaces=vlan_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_vlanl_interfaces_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ vlan_interfaces: Annotated[Optional[VlanInterfaces], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a VLAN interface
+
+ Update an existing VLAN interface.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param vlan_interfaces: OK
+ :type vlan_interfaces: VlanInterfaces
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_vlanl_interfaces_by_id_serialize(
+ id=id,
+ vlan_interfaces=vlan_interfaces,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "VlanInterfaces",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_vlan_interfaces(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single vlan_interfaces object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_vlan_interfaces(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_vlan_interfaces(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_vlanl_interfaces_by_id_serialize(
+ self,
+ id,
+ vlan_interfaces,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if vlan_interfaces is not None:
+ _body_params = vlan_interfaces
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/vlan-interfaces/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api/zone_protection_profiles_api.py b/scm/network_services/api/zone_protection_profiles_api.py
new file mode 100644
index 00000000..8fd36ad7
--- /dev/null
+++ b/scm/network_services/api/zone_protection_profiles_api.py
@@ -0,0 +1,1619 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from scm.network_services.models.zone_protection_profiles import ZoneProtectionProfiles
+from scm.network_services.models.zone_protection_profiles_list_response import ZoneProtectionProfilesListResponse
+
+from scm.network_services.api_client import ApiClient, RequestSerialized
+from scm.network_services.api_response import ApiResponse
+from scm.network_services.rest import RESTResponseType
+from scm.decorators import with_error_handling
+
+
+
+class ZoneProtectionProfilesApi:
+ """NOTE: This class is auto generated by OpenAPI Generator
+ Ref: https://openapi-generator.tech
+
+ Do not edit the class manually.
+ """
+
+ def __init__(self, api_client=None) -> None:
+ if api_client is None:
+ api_client = ApiClient.get_default()
+ self.api_client = api_client
+
+
+ @validate_call
+ @with_error_handling
+ def create_zone_protection_profiles(
+ self,
+ zone_protection_profiles: Annotated[Optional[ZoneProtectionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ZoneProtectionProfiles:
+ """Create a zone protection profile
+
+ Create a new zone protection profile.
+
+ :param zone_protection_profiles: Created
+ :type zone_protection_profiles: ZoneProtectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_zone_protection_profiles_serialize(
+ zone_protection_profiles=zone_protection_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def create_zone_protection_profiles_with_http_info(
+ self,
+ zone_protection_profiles: Annotated[Optional[ZoneProtectionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ZoneProtectionProfiles]:
+ """Create a zone protection profile
+
+ Create a new zone protection profile.
+
+ :param zone_protection_profiles: Created
+ :type zone_protection_profiles: ZoneProtectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_zone_protection_profiles_serialize(
+ zone_protection_profiles=zone_protection_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def create_zone_protection_profiles_without_preload_content(
+ self,
+ zone_protection_profiles: Annotated[Optional[ZoneProtectionProfiles], Field(description="Created")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Create a zone protection profile
+
+ Create a new zone protection profile.
+
+ :param zone_protection_profiles: Created
+ :type zone_protection_profiles: ZoneProtectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._create_zone_protection_profiles_serialize(
+ zone_protection_profiles=zone_protection_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '201': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _create_zone_protection_profiles_serialize(
+ self,
+ zone_protection_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if zone_protection_profiles is not None:
+ _body_params = zone_protection_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='POST',
+ resource_path='/zone-protection-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def delete_zone_protection_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> None:
+ """Delete a zone protection profile
+
+ Delete a zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_zone_protection_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def delete_zone_protection_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[None]:
+ """Delete a zone protection profile
+
+ Delete a zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_zone_protection_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def delete_zone_protection_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Delete a zone protection profile
+
+ Delete a zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._delete_zone_protection_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': None,
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _delete_zone_protection_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='DELETE',
+ resource_path='/zone-protection-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def get_zone_protection_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ZoneProtectionProfiles:
+ """Get a zone protection profile
+
+ Get an existing zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_zone_protection_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def get_zone_protection_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ZoneProtectionProfiles]:
+ """Get a zone protection profile
+
+ Get an existing zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_zone_protection_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def get_zone_protection_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Get a zone protection profile
+
+ Get an existing zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._get_zone_protection_profiles_by_id_serialize(
+ id=id,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _get_zone_protection_profiles_by_id_serialize(
+ self,
+ id,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/zone-protection-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def list_zone_protection_profiles(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ZoneProtectionProfilesListResponse:
+ """List zone protection profiles
+
+ Retrieve a list of zone protection profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_zone_protection_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def list_zone_protection_profiles_with_http_info(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ZoneProtectionProfilesListResponse]:
+ """List zone protection profiles
+
+ Retrieve a list of zone protection profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_zone_protection_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def list_zone_protection_profiles_without_preload_content(
+ self,
+ limit: Annotated[Optional[StrictInt], Field(description="The maximum number of results per page")] = None,
+ offset: Annotated[Optional[StrictInt], Field(description="The offset into the list of results returned")] = None,
+ name: Annotated[Optional[StrictStr], Field(description="The name of the configuration resource")] = None,
+ folder: Annotated[Optional[StrictStr], Field(description="The folder in which the resource is defined ")] = None,
+ snippet: Annotated[Optional[StrictStr], Field(description="The snippet in which the resource is defined ")] = None,
+ device: Annotated[Optional[StrictStr], Field(description="The device in which the resource is defined ")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """List zone protection profiles
+
+ Retrieve a list of zone protection profiles.
+
+ :param limit: The maximum number of results per page
+ :type limit: int
+ :param offset: The offset into the list of results returned
+ :type offset: int
+ :param name: The name of the configuration resource
+ :type name: str
+ :param folder: The folder in which the resource is defined
+ :type folder: str
+ :param snippet: The snippet in which the resource is defined
+ :type snippet: str
+ :param device: The device in which the resource is defined
+ :type device: str
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._list_zone_protection_profiles_serialize(
+ limit=limit,
+ offset=offset,
+ name=name,
+ folder=folder,
+ snippet=snippet,
+ device=device,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfilesListResponse",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+ def _list_zone_protection_profiles_serialize(
+ self,
+ limit,
+ offset,
+ name,
+ folder,
+ snippet,
+ device,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ # process the query parameters
+ if limit is not None:
+
+ _query_params.append(('limit', limit))
+
+ if offset is not None:
+
+ _query_params.append(('offset', offset))
+
+ if name is not None:
+
+ _query_params.append(('name', name))
+
+ if folder is not None:
+
+ _query_params.append(('folder', folder))
+
+ if snippet is not None:
+
+ _query_params.append(('snippet', snippet))
+
+ if device is not None:
+
+ _query_params.append(('device', device))
+
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='GET',
+ resource_path='/zone-protection-profiles',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
+
+
+ @validate_call
+ @with_error_handling
+ def update_zone_protection_profiles_by_id(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ zone_protection_profiles: Annotated[Optional[ZoneProtectionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ZoneProtectionProfiles:
+ """Update a zone protection profile
+
+ Update an existing zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param zone_protection_profiles: OK
+ :type zone_protection_profiles: ZoneProtectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_zone_protection_profiles_by_id_serialize(
+ id=id,
+ zone_protection_profiles=zone_protection_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ ).data
+
+
+ @validate_call
+ @with_error_handling
+ def update_zone_protection_profiles_by_id_with_http_info(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ zone_protection_profiles: Annotated[Optional[ZoneProtectionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> ApiResponse[ZoneProtectionProfiles]:
+ """Update a zone protection profile
+
+ Update an existing zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param zone_protection_profiles: OK
+ :type zone_protection_profiles: ZoneProtectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_zone_protection_profiles_by_id_serialize(
+ id=id,
+ zone_protection_profiles=zone_protection_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ response_data.read()
+ return self.api_client.response_deserialize(
+ response_data=response_data,
+ response_types_map=_response_types_map,
+ )
+
+
+ @validate_call
+ @with_error_handling
+ def update_zone_protection_profiles_by_id_without_preload_content(
+ self,
+ id: Annotated[StrictStr, Field(description="The UUID of the configuration resource")],
+ zone_protection_profiles: Annotated[Optional[ZoneProtectionProfiles], Field(description="OK")] = None,
+ _request_timeout: Union[
+ None,
+ Annotated[StrictFloat, Field(gt=0)],
+ Tuple[
+ Annotated[StrictFloat, Field(gt=0)],
+ Annotated[StrictFloat, Field(gt=0)]
+ ]
+ ] = None,
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
+ _content_type: Optional[StrictStr] = None,
+ _headers: Optional[Dict[StrictStr, Any]] = None,
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+ ) -> RESTResponseType:
+ """Update a zone protection profile
+
+ Update an existing zone protection profile.
+
+ :param id: The UUID of the configuration resource (required)
+ :type id: str
+ :param zone_protection_profiles: OK
+ :type zone_protection_profiles: ZoneProtectionProfiles
+ :param _request_timeout: timeout setting for this request. If one
+ number provided, it will be total request
+ timeout. It can also be a pair (tuple) of
+ (connection, read) timeouts.
+ :type _request_timeout: int, tuple(int, int), optional
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the
+ authentication in the spec for a single request.
+ :type _request_auth: dict, optional
+ :param _content_type: force content-type for the request.
+ :type _content_type: str, Optional
+ :param _headers: set to override the headers for a single
+ request; this effectively ignores the headers
+ in the spec for a single request.
+ :type _headers: dict, optional
+ :param _host_index: set to override the host_index for a single
+ request; this effectively ignores the host_index
+ in the spec for a single request.
+ :type _host_index: int, optional
+ :return: Returns the result object.
+ """ # noqa: E501
+
+ _param = self._update_zone_protection_profiles_by_id_serialize(
+ id=id,
+ zone_protection_profiles=zone_protection_profiles,
+ _request_auth=_request_auth,
+ _content_type=_content_type,
+ _headers=_headers,
+ _host_index=_host_index
+ )
+
+ _response_types_map: Dict[str, Optional[str]] = {
+ '200': "ZoneProtectionProfiles",
+ '400': "GenericError",
+ '401': "GenericError",
+ '403': "GenericError",
+ '404': "GenericError",
+ '409': "GenericError",
+ }
+ response_data = self.api_client.call_api(
+ *_param,
+ _request_timeout=_request_timeout
+ )
+ return response_data.response
+
+
+
+ def fetch_zone_protection_profiles(
+ self,
+ name: str,
+ folder: Optional[str] = None,
+ snippet: Optional[str] = None,
+ device: Optional[str] = None,
+ **kwargs
+ ) -> Optional[Any]:
+ """
+ Fetch a single zone_protection_profiles object by name.
+
+ This is a convenience method that uses server-side name filtering to retrieve
+ a specific object by its name within a container (folder, snippet, or device).
+
+ Args:
+ name: The name of the object to fetch
+ folder: The folder in which the resource is defined
+ snippet: The snippet in which the resource is defined
+ device: The device in which the resource is defined
+ **kwargs: Additional keyword arguments
+
+ Returns:
+ The matching object if found, None otherwise
+
+ Example:
+ >>> obj = api.fetch_zone_protection_profiles(name="my-object", folder="Texas")
+ >>> if obj:
+ ... print(f"Found: {obj.name}")
+ """
+ # Build list parameters with server-side name filter
+ list_params = {'name': name, 'limit': 5000}
+ if folder is not None:
+ list_params['folder'] = folder
+ if snippet is not None:
+ list_params['snippet'] = snippet
+ if device is not None:
+ list_params['device'] = device
+ # Add any additional kwargs (excluding offset/limit/name which we handle separately)
+ list_params.update({k: v for k, v in kwargs.items() if k not in ['offset', 'limit', 'name']})
+
+ try:
+ response = self.list_zone_protection_profiles(**list_params)
+ except Exception as e:
+ # HTTP 404: object not found - return None
+ if hasattr(e, 'http_status_code') and e.http_status_code == 404:
+ return None
+ if hasattr(e, 'status') and e.status == 404:
+ return None
+ raise
+
+ # Standard paginated response - verify exact name match
+ if hasattr(response, 'data') and response.data:
+ for obj in response.data:
+ if hasattr(obj, 'name'):
+ if obj.name == name:
+ return obj
+ else:
+ return obj
+
+ return None
+
+ def _update_zone_protection_profiles_by_id_serialize(
+ self,
+ id,
+ zone_protection_profiles,
+ _request_auth,
+ _content_type,
+ _headers,
+ _host_index,
+ ) -> RequestSerialized:
+
+ _host = None
+
+ _collection_formats: Dict[str, str] = {
+ }
+
+ _path_params: Dict[str, str] = {}
+ _query_params: List[Tuple[str, str]] = []
+ _header_params: Dict[str, Optional[str]] = _headers or {}
+ _form_params: List[Tuple[str, str]] = []
+ _files: Dict[
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+ ] = {}
+ _body_params: Optional[bytes] = None
+
+ # process the path parameters
+ if id is not None:
+ _path_params['id'] = id
+ # process the query parameters
+ # process the header parameters
+ # process the form parameters
+ # process the body parameter
+ if zone_protection_profiles is not None:
+ _body_params = zone_protection_profiles
+
+
+ # set the HTTP header `Accept`
+ if 'Accept' not in _header_params:
+ _header_params['Accept'] = self.api_client.select_header_accept(
+ [
+ 'application/json'
+ ]
+ )
+
+ # set the HTTP header `Content-Type`
+ if _content_type:
+ _header_params['Content-Type'] = _content_type
+ else:
+ _default_content_type = (
+ self.api_client.select_header_content_type(
+ [
+ 'application/json'
+ ]
+ )
+ )
+ if _default_content_type is not None:
+ _header_params['Content-Type'] = _default_content_type
+
+ # authentication setting
+ _auth_settings: List[str] = [
+ 'scmToken'
+ ]
+
+ return self.api_client.param_serialize(
+ method='PUT',
+ resource_path='/zone-protection-profiles/{id}',
+ path_params=_path_params,
+ query_params=_query_params,
+ header_params=_header_params,
+ body=_body_params,
+ post_params=_form_params,
+ files=_files,
+ auth_settings=_auth_settings,
+ collection_formats=_collection_formats,
+ _host=_host,
+ _request_auth=_request_auth
+ )
+
+
diff --git a/scm/network_services/api_client.py b/scm/network_services/api_client.py
new file mode 100644
index 00000000..a62354e8
--- /dev/null
+++ b/scm/network_services/api_client.py
@@ -0,0 +1,798 @@
+# coding: utf-8
+
+"""
+ Network Services
+
+ These APIs are used for defining and managing network services configuration within Strata Cloud Manager.
+
+ The version of the OpenAPI document: 2.0.0
+ Contact: support@paloaltonetworks.com
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+ Do not edit the class manually.
+""" # noqa: E501
+
+
+import datetime
+from dateutil.parser import parse
+from enum import Enum
+import decimal
+import json
+import mimetypes
+import os
+import re
+import tempfile
+
+from urllib.parse import quote
+from typing import Tuple, Optional, List, Dict, Union
+from pydantic import SecretStr
+
+from scm.network_services.configuration import Configuration
+from scm.network_services.api_response import ApiResponse, T as ApiResponseT
+import scm.network_services.models
+from scm.network_services import rest
+from scm.network_services.exceptions import (
+ ApiValueError,
+ ApiException,
+ BadRequestException,
+ UnauthorizedException,
+ ForbiddenException,
+ NotFoundException,
+ ServiceException
+)
+
+RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]]
+
+class ApiClient:
+ """Generic API client for OpenAPI client library builds.
+
+ OpenAPI generic API client. This client handles the client-
+ server communication, and is invariant across implementations. Specifics of
+ the methods and models for each application are generated from the OpenAPI
+ templates.
+
+ :param configuration: .Configuration object for this client
+ :param header_name: a header to pass when making calls to the API.
+ :param header_value: a header value to pass when making calls to
+ the API.
+ :param cookie: a cookie to include in the header when making calls
+ to the API
+ """
+
+ PRIMITIVE_TYPES = (float, bool, bytes, str, int)
+ NATIVE_TYPES_MAPPING = {
+ 'int': int,
+ 'long': int, # TODO remove as only py3 is supported?
+ 'float': float,
+ 'str': str,
+ 'bool': bool,
+ 'date': datetime.date,
+ 'datetime': datetime.datetime,
+ 'decimal': decimal.Decimal,
+ 'object': object,
+ }
+ _pool = None
+
+ def __init__(
+ self,
+ configuration=None,
+ header_name=None,
+ header_value=None,
+ cookie=None
+ ) -> None:
+ # use default configuration if none is provided
+ if configuration is None:
+ configuration = Configuration.get_default()
+ self.configuration = configuration
+
+ self.rest_client = rest.RESTClientObject(configuration)
+ self.default_headers = {}
+ if header_name is not None:
+ self.default_headers[header_name] = header_value
+ self.cookie = cookie
+ # Set default User-Agent.
+ self.user_agent = 'OpenAPI-Generator/1.0.0/python'
+ self.client_side_validation = configuration.client_side_validation
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, exc_type, exc_value, traceback):
+ pass
+
+ @property
+ def user_agent(self):
+ """User agent for this API client"""
+ return self.default_headers['User-Agent']
+
+ @user_agent.setter
+ def user_agent(self, value):
+ self.default_headers['User-Agent'] = value
+
+ def set_default_header(self, header_name, header_value):
+ self.default_headers[header_name] = header_value
+
+
+ _default = None
+
+ @classmethod
+ def get_default(cls):
+ """Return new instance of ApiClient.
+
+ This method returns newly created, based on default constructor,
+ object of ApiClient class or returns a copy of default
+ ApiClient.
+
+ :return: The ApiClient object.
+ """
+ if cls._default is None:
+ cls._default = ApiClient()
+ return cls._default
+
+ @classmethod
+ def set_default(cls, default):
+ """Set default instance of ApiClient.
+
+ It stores default ApiClient.
+
+ :param default: object of ApiClient.
+ """
+ cls._default = default
+
+ def param_serialize(
+ self,
+ method,
+ resource_path,
+ path_params=None,
+ query_params=None,
+ header_params=None,
+ body=None,
+ post_params=None,
+ files=None, auth_settings=None,
+ collection_formats=None,
+ _host=None,
+ _request_auth=None
+ ) -> RequestSerialized:
+
+ """Builds the HTTP request params needed by the request.
+ :param method: Method to call.
+ :param resource_path: Path to method endpoint.
+ :param path_params: Path parameters in the url.
+ :param query_params: Query parameters in the url.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param auth_settings list: Auth Settings names for the request.
+ :param files dict: key -> filename, value -> filepath,
+ for `multipart/form-data`.
+ :param collection_formats: dict of collection formats for path, query,
+ header, and post parameters.
+ :param _request_auth: set to override the auth_settings for an a single
+ request; this effectively ignores the authentication
+ in the spec for a single request.
+ :return: tuple of form (path, http_method, query_params, header_params,
+ body, post_params, files)
+ """
+
+ config = self.configuration
+
+ # header parameters
+ header_params = header_params or {}
+ header_params.update(self.default_headers)
+ if self.cookie:
+ header_params['Cookie'] = self.cookie
+ if header_params:
+ header_params = self.sanitize_for_serialization(header_params)
+ header_params = dict(
+ self.parameters_to_tuples(header_params,collection_formats)
+ )
+
+ # path parameters
+ if path_params:
+ path_params = self.sanitize_for_serialization(path_params)
+ path_params = self.parameters_to_tuples(
+ path_params,
+ collection_formats
+ )
+ for k, v in path_params:
+ # specified safe chars, encode everything
+ resource_path = resource_path.replace(
+ '{%s}' % k,
+ quote(str(v), safe=config.safe_chars_for_path_param)
+ )
+
+ # post parameters
+ if post_params or files:
+ post_params = post_params if post_params else []
+ post_params = self.sanitize_for_serialization(post_params)
+ post_params = self.parameters_to_tuples(
+ post_params,
+ collection_formats
+ )
+ if files:
+ post_params.extend(self.files_parameters(files))
+
+ # auth setting
+ self.update_params_for_auth(
+ header_params,
+ query_params,
+ auth_settings,
+ resource_path,
+ method,
+ body,
+ request_auth=_request_auth
+ )
+
+ # body
+ if body:
+ body = self.sanitize_for_serialization(body)
+
+ # request url
+ if _host is None or self.configuration.ignore_operation_servers:
+ url = self.configuration.host + resource_path
+ else:
+ # use server/host defined in path or operation instead
+ url = _host + resource_path
+
+ # query parameters
+ if query_params:
+ query_params = self.sanitize_for_serialization(query_params)
+ url_query = self.parameters_to_url_query(
+ query_params,
+ collection_formats
+ )
+ url += "?" + url_query
+
+ return method, url, header_params, body, post_params
+
+
+ def call_api(
+ self,
+ method,
+ url,
+ header_params=None,
+ body=None,
+ post_params=None,
+ _request_timeout=None
+ ) -> rest.RESTResponse:
+ """Makes the HTTP request (synchronous)
+ :param method: Method to call.
+ :param url: Path to method endpoint.
+ :param header_params: Header parameters to be
+ placed in the request header.
+ :param body: Request body.
+ :param post_params dict: Request post form parameters,
+ for `application/x-www-form-urlencoded`, `multipart/form-data`.
+ :param _request_timeout: timeout setting for this request.
+ :return: RESTResponse
+ """
+
+ try:
+ # perform request and return response
+ response_data = self.rest_client.request(
+ method, url,
+ headers=header_params,
+ body=body, post_params=post_params,
+ _request_timeout=_request_timeout
+ )
+
+ except ApiException as e:
+ raise e
+
+ return response_data
+
+ def response_deserialize(
+ self,
+ response_data: rest.RESTResponse,
+ response_types_map: Optional[Dict[str, ApiResponseT]]=None
+ ) -> ApiResponse[ApiResponseT]:
+ """Deserializes response into an object.
+ :param response_data: RESTResponse object to be deserialized.
+ :param response_types_map: dict of response types.
+ :return: ApiResponse
+ """
+
+ msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
+ assert response_data.data is not None, msg
+
+ response_type = response_types_map.get(str(response_data.status), None)
+ if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
+ # if not found, look for '1XX', '2XX', etc.
+ response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)
+
+ # deserialize response data
+ response_text = None
+ return_data = None
+ try:
+ if response_type == "bytearray":
+ return_data = response_data.data
+ elif response_type == "file":
+ return_data = self.__deserialize_file(response_data)
+ elif response_type is not None:
+ match = None
+ content_type = response_data.getheader('content-type')
+ if content_type is not None:
+ match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
+ encoding = match.group(1) if match else "utf-8"
+ response_text = response_data.data.decode(encoding)
+ return_data = self.deserialize(response_text, response_type, content_type)
+ finally:
+ if not 200 <= response_data.status <